.. include:: common.inc

Current Status -- |current-status|
==================================

.. current_status_text

.. warning::
   The SKY90FD PDK is currently under development and **not** yet available.

Google and SkyWater, with help from our partners like `Efabless <https://efabless.com>`_, `Precision Innovations <https://precisioninno.com>`_, and `Antmicro <https://antmicro.com>`_, are working together to release an open source process design kit (PDK) for SKY90-FD, SkyWater’s commercial 90nm fully depleted silicon on insulator (FDSOI) CMOS process technology. SKY90-FD is based on MIT Lincoln Laboratory’s 90 nm commercial FDSOI technology, and enables designers to create complex integrated circuits for a diverse range of applications.

The PDK will be tagged with a production version when ready to do production design, see the ":ref:`Versioning Information`" section for a full description of the version numbering scheme.

To get notified about future new releases of the PDK, and other important news, please sign up on the
`sky90fd-pdk-announce mailing list <https://groups.google.com/forum/#!forum/sky90fd-pdk-announce>`_
[`join link <https://groups.google.com/forum/#!forum/sky90fd-pdk-announce/join>`_].
