🎥 Video Tutorials¶

🚀 Getting Started¶

👥 Sign Up & Invite Your Team¶

• 🔐 Signing Up for GDSFactory+

  • The first person in the organization to sign up should be the Organization Admin.
  • Organization Admins can manage users and invite team members.

• 📧 Inviting Team Members

  • Use the invitation system to invite your colleagues to your organization.
  • Invitations ensure that users are automatically linked to your organization upon signup.

• ✉️ How to Send an Invitation

  • Navigate to the Invitations tab in your dashboard.
  • Click the New Invitation button.
  • Enter the recipient's email address.
  • Assign their role:
    • 👑 Admin: Manage organization users and invite others.
    • 👤 User: Access resources within the organization.
  • Click Invite to send the invitation.

• 📨 What Happens After Sending an Invitation

  • The recipient receives an email with a signup link. If your colleagues don't see the email, ask them to check their spam or junk folder.
  • Clicking the link redirects them to the GDSFactory+ sign-up page.
  • After signing up, they are automatically added to your organization.

🔧 Install GDSFactory+ Extension in VSCode¶

If you only plan to use the cloud workspaces, you can skip this part.

• 📦 Steps to install the extension:

  • Open Visual Studio Code.
  • Navigate to the Extensions tab (icon with four squares) and install the GDSFactory+ extension

• ✅ Verifying the installation:

  • Check for new menu items PDK and DRC on the left menu bar after restarting.
  • If these appear, the extension has been installed successfully.

• 🔑 Setting up the API key:

  • Go to the GDSFactory+ website and navigate to the API Keys section.
  • Create a new API key by clicking "Create New API Key" and naming it (e.g., my api key).
  • View and copy the generated API key using the eye icon.
  • In VS Code, click the PDK icon on the left menu bar.
  • Open Settings, select "Edit Global Settings," and paste the API key in the key field.
  • Reload window.
  • Make sure you open a GDSFactory+ project for the extension to work properly.

💻 Install Linux via Windows Subsystem for Linux (WSL) Optional¶

If you're using Windows, you can also install a Linux distribution through the Windows Subsystem for Linux (WSL). This allows you to run GDSFactory+ in a native Linux environment directly on your Windows machine, offering faster performance and better compatibility with photonic design tools. For that you can open a PowerShell and type wsl --install and restart your computer. Once WSL is installed and set up, you can open your Linux environment directly in Visual Studio Code using the Remote - WSL extension. This provides a seamless development experience, as if you were working on a native Linux machine. For that you can open WSL terminal and type code .

📦 Upload Private Python Packages to Your Organization's Package Index¶

This video shows you how to upload private PDKs from foundries or other private packages to your organization's private package index such as internal PDKs.

• 🚀 Demonstration of uploading private Python packages to an organization's private package index.
  • Example used: a PDK (Process Design Kit) package for demopdk.
  • Purpose: Streamline workflows and maintain security across projects.
• ⬆️ Uploading the Package
  • Navigate to the private package index.
  • Upload the wheel (.whl) file for the package, e.g., DemoPDK.
  • Once uploaded, the package becomes immediately available for other projects.
• 💡 Tips for Compatibility
  • Some packages require different wheel files based on:
    • Operating system (Windows, macOS, Linux).
    • Python version.
  • Upload multiple wheel files to ensure compatibility across operating systems.
• 🎯 Using the Uploaded Package
  • Open a demo project that depends on DemoPDK.
  • Check pyproject.toml to verify DemoPDK version (e.g., 0.12.4) is correctly specified.
  • Open the GDSFactory+ app:
    • It detects project dependencies.
    • Prompts to configure the environment.
    • Downloads and installs the necessary packages from the private index.
• ✨ Conclusion
  • Successfully uploaded and utilized a private package.
  • Maintains package security and simplifies management across the organization.

☁️ Create & Manage Cloud Workspaces¶

If you plan to use the Local VSCode extension, you can skip this part.

• 🌐 Introduction to Workspaces
  • Learn how to create and manage your workspaces on the GDSFactory+ dashboard.
  • Workspaces allow you to edit projects connected to your GitHub account.
• 📋 Before You Begin
  • Go to the Dashboard tab and connect your GitHub account.
  • This connection enables you to create workspaces for your projects.
  • In this example, the organization is "GDSFactoryPlus." You will see your organization's name instead.
  • Note: To access projects, you must be an organization owner. Contact your organization owner if needed.
• 👀 Making Projects Visible
  • A project must have the "GFP" topic added to appear on the GDSFactory+ dashboard.
  • To add the topic:
    • Navigate to the project's Settings on GitHub.
    • Find the Topics section.
    • Add "GFP" as a topic.
• 🏗️ Creating a Workspace
  • Enter a name for your workspace and select the GitHub project you'd like to edit.
  • Example: Create a workspace named john and choose an open-source project, such as Cornerstone Silicon 220 nm PDK.
• ⚙️ Workspace Setup
  • Workspace setup takes about a minute and progresses through 🟡 Starting and ✅ Running
  • Once ready, the dashboard displays:
    • Workspace Name
    • Associated Project
    • Generated URL to access the workspace
  • To remove a workspace, click the trash icon.
    • ⚠️ Important: Sync your work before deleting, as this action is irreversible.
• 🚪 Accessing Your Workspace
  • Click the URL in the dashboard or open it in a new browser tab.
  • Once inside, begin working on your project.

📚 Library Management¶

🔍 PDK Explorer¶

• 🔎 Introduction to Browsing Components: Learn to browse both Project Components and Foundry Components using the PDK Explorer. The PDK tab organizes components, with Project Components at the top and Foundry Components at the bottom.
• 📂 Exploring Project Components Click on any Project Component to view its details. Access various options depending on the component, such as:
  • 📐 GDS File: View the design layout.
  • 📊 Schematic: Open the schematic editor to define or modify circuits.
  • ✏️ Edit: Update component details or source code.
  • 📜 Logs: Review design logs.
• 🔧 Working with Schematics
  • Open the schematic editor to define or refine circuits.
  • Ensure that your layout implementation matches the intended design.
  • Modify source code, update schematics, or view the GDS layout as needed.

🆕 Create New Projects from Templates¶

Learn how to quickly create a new photonic chip design project using a PDK template in GDSFactory+. In this tutorial, we walk through how to use the GDSFactory+ VSCode extension to generate a new project from a pre-defined template. Whether you're working with an open-access PDK like Cornerstone or a private PDK under NDA, this video shows you how to set up your environment and get started with sample components and Jupyter notebooks.

🎨 Customizing PDK Layer Views¶

In this advanced GDSFactory tutorial, we walk through how to modify a Process Design Kit (PDK) by customizing layer views using the Cornerstone CSPDK. You’ll learn how to edit layer properties in KLayout (e.g., changing layer colors), save your custom layer.lyp file, and integrate it into your PDK setup using Python. The video covers editing the init.py file, applying changes, and verifying the results in GDSFactory. Perfect for designers looking to tailor their layout visualizations for better clarity and control.

🧑‍🎨 Layout Design¶

📋 Create New Schematics¶

• 🎯 Introduction to Schematic-Driven Layout Learn to create a schematic-driven layout using the PDK tab and schematic editor.

• ➕ Creating a New Project Component: Click the PDK tab and then the + button to create a new Project Component. Choose Schematic for circuits and name it, e.g., rings_filter.

• 🔲 Adding Instances Press I to add instances of components. For example:
  • Add ring_single_sc and name it R1.
  • Add another ring_single_sc and name it R2.
  • Save the schematic and open the layout side by side for better visibility.
  • Initially, components will overlap as no placements or connections are defined.
• 🔗 Defining Connections
  • Open the schematic view and press L to create links between components.
  • Save the schematic and use Zoom Fit to view the connected components.
• 🎨 Refining the Design
  • Modify the size or placement of components like R2 and save the changes.
• 🚪 Adding Ports
  • Press P to create ports, naming them, e.g., O1 (input) and O2 (output).
  • Use L to link the ports, establishing input and output connections.
  • Enable Show Ports to visualize the ports and verify the setup.
• ⚡ Running Circuit Simulations
  • Run circuit simulations with options such as:
    • Exporting to a Cadence Spectre netlist.
    • Running simulations in a Jupyter Notebook.
    • Performing simulations locally or remotely.
  • For this demonstration, run the simulation locally and view the results.
• 🛤️ Defining Routed Connections
  • To use routed connections:
    • Break the existing link by pressing L and disconnecting it.
    • Define the placement of R2, e.g., move it 100 microns to the right.
    • Edit the link to create a route, customize it, and name it, e.g., route_1.
    • Save the schematic.
  • Routed connections adjust automatically if component placements change, keeping the design functional.

🤖 Automatic Routing¶

• 📍 Circuit Placement and Routing

  • Define circuit placements within the schematic
  • Modifying placements in the schematic automatically updates the routing

• 🖱️ Convenient Instance Movement

  • Use the Move Instances option at the top left
  • Drag instances to the desired location, and routes follow automatically
  • Works with:
    • Single routes (e.g., lattice filter example)
    • Bundle routes (regenerates automatically when clicked on the component)

• ⭐ GDS Factory Plus Feature: ASTAR Bundle Router

  • Exclusive to GDS Factory Plus users
  • Allows dynamic instance movement while:
    • Automatically reconfiguring routes to avoid obstacles
    • Maintaining optimal connections

🐍 Create New Components in Python¶

In this video, I'll guide you through the process of creating new Components in Python.

• 🚀 Getting Started

  • Navigate to the PDK tab on the left side of the screen.
  • Click the + button to create a new Project Component.
  • Choose to create a Component in Python.
  • Name the file demo.

• 🔷 Create Your First Cell:

  • Click on the Add Cell button.
  • A Cell is a function that returns a Component.
  • A Component acts as an empty canvas where you can add polygons or instances of other components.
  • Name your cell demo1 and add a polygon.

• 👀 Visualize Components Side by Side:

  • Drag the visualization window to the right to see the component's code and GDS layout simultaneously.

• 🔲 Create a Grid of Components:

  • Add a new cell called demo2.
  • Use the gf.grid function to arrange multiple components in a grid layout.
  • Save the file to view the grid.

• 📦 Optimize Space with the Pack Function:

  • Add another cell named demo3.
  • Use the pack function to arrange multiple components efficiently, minimizing unused space.
  • Reuse components created earlier for the demonstration.
  • Save the file, and the packed layout will update automatically.

• 📥 Import Components from GDS Files:

  • Create a new cell named demo4.
  • Use the import_gds function to import a layout from an existing GDS file.
  • Copy the file path using the "Copy Path" feature from your file manager and paste it into the code.
  • Save the file to visualize the imported GDS layout.

• 🔌 Add Ports to Your Component:

  • Use the Component.add_port function to add ports for connectivity.
  • Define the port attributes:
    • Name: e.g., o1
    • Center: Specify the port's center coordinates.
    • Width: Set the port's width.
    • Orientation: Define the port's direction.
    • Layer: Indicate the port's layer.

📌 Summary - In this video, we learned how to:

• Create new Components in Python.
• Add polygons and arrange components in a grid.
• Optimize layouts with the pack function.
• Import layouts from GDS files.
• Add ports for component connectivity.

🧩 Write New PCells in Python Based on Generic PDK¶

📏 Create new Cross-sections¶

In this video, you’ll learn how to define and apply custom cross-sections in GDSFactory+. Cross-sections allow you to group multiple layers with different widths into a single, reusable configuration. We walk through the process of creating a new cross-section (strip_900), restarting the server to apply the changes, and using the cross-section in a new schematic. By the end, you’ll understand how to integrate your custom cross-sections into components within your custom PDK.

✅ Verification (DRC, Connectivity, LVS)¶

🔍 Run DRC on GDS Files¶

DRC (Design Rule Check) ensures your design meets foundry rules.

• 📁 Step 1: Prepare Your GDS File Create a GDS file directly in the app or upload one from your system.
  • Open the GDS file within the platform. Multiple GDS files can be opened by clicking on each, appearing on the right side.
• ▶️ Step 2: Run DRC With the GDS file selected, click the "Check DRC" button.
• 📊 Step 3: Review DRC Results After DRC completes, review errors in the DRC tab. The left DRC tab allows you to hover over each error type, showing the number of violations for each.
• 🔎 Step 4: Inspect Specific Violations. For a minimum width violation, clicking on it displays the affected component. Clicking through each error shows you the detailed information.

💻 Run DRC & Review Results Locally¶

• 🏠 Overview of Local DRC Execution and Review

  • Learn to run DRC (Design Rule Check) and review results locally on your computer.

• ⚙️ Setting Up in VS Code

  • Open the VS Code Editor and start a notebook from the tutorials.
  • Import the Cornerstone PDK, an open-source PDK, and load the configuration.
  • Select the appropriate PDK and render the GDS file.

• 🚀 Running the DRC Check

  • Once the GDS is rendered, execute gfp.check to initiate the DRC.
  • The DRC runs on the server, after which results can be downloaded for local visualization.

• 📈 Reviewing DRC Results

  • Review the errors locally; example results include one minimum width violation and five minimum space violations.
  • Errors can be browsed directly on your computer.

• ☁️ Using the API for Cloud-Based DRC Execution

  • The API uploads the GDS file to the cloud, performs the DRC, and downloads the results.
  • Ensure the GDSFactoryplus Python library and GDSFactory K-Layout extension are installed for full functionality.

• 📦 Installing the GDSFactory KLayout Extension If not installed, go to Klayout > Tools > Packages in VS Code to download the GDSFactory extension.

🔗 Check Connectivity¶

• 🔍 Identifying Connectivity Issues
  • Open the PDK component you want to check.
  • Identify connectivity errors, such as overlapping waveguides.
  • Overlapping waveguides may be obvious in simple layouts but harder to detect in complex layouts.
• ▶️ Running the Connectivity Check
  • Click the DRC button to start the connectivity check and press Check Connectivity
  • Results are displayed in the DRC Verification tab.
  • Errors are categorized for easier review:
    • 🔴 Instance Overlaps: Displays all overlapping instances.
    • ⚠️ Orphan Ports: Highlights disconnected ports.
  • Highlight specific issues in the layout to inspect them in detail.

🧮 Simulations¶

📈 Creating Custom Circuit Models¶

In this tutorial, you’ll learn how to create your own custom components and attach simulation models using GDSFactory. We’ll walk through building a custom Grating Coupler, wrapping an existing SAX model, modifying its properties (e.g., to simulate 3 dB insertion loss), and running a simple circuit simulation using a schematic with input and output ports. Perfect for anyone looking to extend their PDK with custom functionality.

🤝 Collaboration¶

🤖 AI Agent¶

GDSFactory+ features an integrated AI assistant that streamlines photonic chip design by generating hierarchical YAML netlists. After activating a PDK, users can prompt the assistant (e.g., "two rings with a route") to create schematics using both custom and foundry components. Once reviewed and applied, the design can be visualized in GDS format, with auto-updating routes based on schematic-level changes.

🌿 Git Version Control¶

GDSFactory supports seamless integration with Git, a powerful version control system that helps you track changes, collaborate with teammates, and manage your design projects efficiently.

📚 In this tutorial, you'll learn how to:

• 🌱 Create a new Git branch in VS Code by clicking the branch icon in the bottom left corner.
• 📝 Make and view code changes, and stage them using the Git menu.
• 💾 Commit your changes with descriptive messages—like taking snapshots of your code over time (think of Git as a "time machine" for your project).
• 🔧 Handle pre-commit hooks, which may format your code automatically before the commit is finalized.
• 🚀 Push your branch to a remote repository and create a pull request so your team can review and merge it into the main branch.
• 🔄 Sync your local main branch after the merge to stay up to date.

This process allows you to collaborate on parametric component designs—like a spiral P-Cell—without stepping on each other's work, making version control in hardware design as robust as it is in software.