Connect
ComposioHQ/awesome-claude-skills
Connect Claude to any app. An agent skill from ComposioHQ/awesome-claude-skills.
Reference for the .ato declarative DSL: type system, connection semantics, constraint model, and standard library.
MITAuto-check passed
Install Ato Language
$ npx skills add atopile/atopile --skill ato-language -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install atopile/atopile ato-language --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/atopile/atopile.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/ato-language .claude/skills/ato-language && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "ato-language" agent skill from https://github.com/atopile/atopile/tree/main/.claude/skills/ato-language into .claude/skills/ato-language/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ato-language", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/atopile/atopile/tree/main/.claude/skills/ato-languageType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add atopile/atopile --skill ato-language -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install atopile/atopile ato-language --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/atopile/atopile.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.claude/skills/ato-language .agents/skills/ato-language && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "ato-language" agent skill from https://github.com/atopile/atopile/tree/main/.claude/skills/ato-language into .agents/skills/ato-language/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ato-language", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add atopile/atopile --skill ato-language -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install atopile/atopile ato-language --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/atopile/atopile.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.claude/skills/ato-language .cursor/skills/ato-language && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "ato-language" agent skill from https://github.com/atopile/atopile/tree/main/.claude/skills/ato-language into .cursor/skills/ato-language/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ato-language", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/atopile/atopile.git --path .claude/skills/ato-language--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add atopile/atopile --skill ato-language -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install atopile/atopile ato-language --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/atopile/atopile.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.claude/skills/ato-language .gemini/skills/ato-language && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "ato-language" agent skill from https://github.com/atopile/atopile/tree/main/.claude/skills/ato-language into .gemini/skills/ato-language/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ato-language", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install atopile/atopile ato-languageInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add atopile/atopile --skill ato-language -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/atopile/atopile.git skills-src && mkdir -p .github/skills && cp -r skills-src/.claude/skills/ato-language .github/skills/ato-language && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "ato-language" agent skill from https://github.com/atopile/atopile/tree/main/.claude/skills/ato-language into .github/skills/ato-language/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ato-language", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add atopile/atopile --skill ato-language -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install atopile/atopile ato-language --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/atopile/atopile.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.claude/skills/ato-language .opencode/skills/ato-language && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "ato-language" agent skill from https://github.com/atopile/atopile/tree/main/.claude/skills/ato-language into .opencode/skills/ato-language/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ato-language", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
ato-language- GitHub stars
- 4k
- Token cost
- ~3.5k tokens
- SKILL.md length
- 904 words
- Files
- 2
- Skills in repo
- 19
- Repo updated
- First seen
- Licence
- MIT
At a glance
Reference for the .ato declarative DSL: type system, connection semantics, constraint model, and standard library.
- Works in 8 steps: Everything is a Node in a Graph → Three Block Types → Composition — Children and Instantiation → …
- Reviewing .ato code
- SKILL.md covers Quick Start, Core Concepts, Statement Reference and Type System, plus 2 more sections
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
Ato Language is an agent skill from atopile/atopile. Reference for the .ato declarative DSL: type system, connection semantics, constraint model, and standard library. Use when authoring or reviewing .ato code.
Its SKILL.md is about 3.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 1 other file (for example `EXTENSION.md`).
The repository describes itself as: Design circuit boards with code! ✨ Get software-like design reuse 🚀, validation, version control and collaboration in hardware; starting with electronics ⚡️. The licence is MIT.
When your agent uses it
- Reviewing .ato code
Example prompts
- “/ato-language”
Workflow steps
8 steps, taken from the step headings in SKILL.md.
What it can do on your machine
Read from SKILL.md and the folder at commit 619eda7. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
No scripts in the folder and no shell commands in SKILL.md (its code samples are ato).
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Ato Language loads about 3.5k tokens when it runs. Until then it costs about 44 tokens; SKILL.md has 904 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
SKILL.md
The full file from atopile/atopile at commit 619eda7, republished under its MIT licence (© atopile). 904 words, ~3,536 tokens.
Download SKILL.mdSave it as
.claude/skills/ato-language/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.- name
- ato-language
- description
- Reference for the `.ato` declarative DSL: type system, connection semantics, constraint model, and standard library. Use when authoring or reviewing `.ato` code.
The ato language
ato is a declarative, constraint-based DSL for describing electronic circuits. There is no control flow, no mutation, and no execution order — you declare what a circuit is, and the compiler + solver resolve it into a valid design.
Quick Start
A minimal complete .ato file:
#pragma experiment("BRIDGE_CONNECT")
import Resistor
import ElectricPower
import Capacitor
module PowerFilter:
"""A simple decoupled power input with a pull-down resistor."""
power = new ElectricPower
decoupling_capacitor = new Capacitor
pulldown_resistor = new Resistor
power.hv ~> decoupling_capacitor ~> power.lv
power.hv ~> pulldown_resistor ~> power.lv
decoupling_capacitor.capacitance = 100nF +/- 20%
pulldown_resistor.resistance = 100kohm +/- 5%
assert power.voltage within 3.0V to 3.6VValidate with ato build from the package directory.
Core Concepts
1. Everything is a Node in a Graph
Every entity (a resistor, a power rail, an I2C bus, a voltage parameter) is a node in a typed graph. Nodes relate to each other through edges: composition (parent–child), connection (same-net), and traits (behavioral metadata). The .ato language is a surface syntax for constructing this graph declaratively.
2. Three Block Types
ato has exactly three ways to define a new type:
| Keyword | Semantics | Typical Use |
|---|---|---|
module | A design unit that contains children and connections | Circuit blocks, subsystems |
interface | A connectable boundary; can be wired with ~ | Buses, power rails, signals |
component | A physical part with footprint/symbol | Vendor ICs, connectors |
All three compile to graph nodes. The distinction controls which traits the compiler attaches (is_module, is_interface) and what operations are legal (by convention, interfaces appear on both sides of ~).
Inheritance uses from:
module MyRegulator from Regulator:
pass3. Composition — Children and Instantiation
Types contain children. Inside a block body, new instantiates a child:
module Board:
power = new ElectricPower # interface child
sensor = new BME280 # module child
caps = new Capacitor[4] # array of 4 capacitorsChildren are accessed via dot-notation: sensor.power.voltage, caps[0].capacitance.
4. Connection — Declaring Electrical Identity
The wire operator ~ declares that two interfaces are the same net/bus. It is bidirectional and requires matching types:
power_3v3 ~ sensor.power # ElectricPower ~ ElectricPower
i2c_bus ~ sensor.i2c # I2C ~ I2CThe bridge operator ~> (requires #pragma experiment("BRIDGE_CONNECT")) inserts a component in series. The component must carry the can_bridge trait which defines its in/out mapping:
power_5v ~> regulator ~> power_3v3
i2c.scl.line ~> pullup ~> power.hv5. Constraints — Physical Quantities and Assertions
Values in ato carry units and tolerances. The solver uses these to select real parts.
Assignment binds a value to a parameter:
power.voltage = 3.3V +/- 5%
resistor.resistance = 10kohm +/- 10%
i2c.frequency = 400kHz
i2c.address = 0x48Assertions declare constraints the solver must satisfy:
assert power.voltage within 3.0V to 3.6V
assert i2c.frequency <= 400kHz
assert sensor.i2c.address is 0x50Three value forms exist:
- Exact:
3.3V - Bilateral tolerance:
10kohm +/- 5% - Bounded range:
3.0V to 3.6V
6. Traits — Behavioral Metadata
Traits attach capabilities or metadata to nodes. They are not children — they use trait edges in the graph.
#pragma experiment("TRAITS")
import has_part_removed
import is_atomic_part
module Placeholder:
trait has_part_removed # mark as non-physical placeholder
trait is_atomic_part # user-defined part with footprintKey built-in traits:
| Trait | Effect |
|---|---|
can_bridge | Enables use with ~> operator (defines in/out pin mapping) |
has_part_removed | No physical part placed (symbolic node) |
is_atomic_part | User-defined part with manufacturer, partnumber, footprint |
has_datasheet | Attaches a datasheet reference |
has_designator_prefix | Sets PCB designator (R, C, U, etc.) |
7. Import System
Bare imports resolve to standard library types (1 line per import):
import ElectricPower
import I2C
import ResistorPath imports resolve to types defined in other .ato files (1 line per import):
from "atopile/vendor-part/vendor-part.ato" import Vendor_Part8. Pragma Feature Flags
Experimental syntax is gated behind pragmas (file top, before imports):
#pragma experiment("BRIDGE_CONNECT") # ~> operator
#pragma experiment("FOR_LOOP") # for loops
#pragma experiment("TRAITS") # trait keyword
#pragma experiment("MODULE_TEMPLATING") # new Foo<p=v>
#pragma experiment("INSTANCE_TRAITS") # traits on instancesUsing gated syntax without the pragma is a compile error.
Statement Reference
Every statement inside a block body is one of:
| Statement | Syntax | Purpose |
|---|---|---|
assign | name = value or name = new Type | Bind a value or instantiate a child |
connect | a ~ b | Wire two interfaces together |
bridge | a ~> b ~> c | Insert bridgeable components in series |
assert | assert expr <op> expr | Declare a constraint |
retype | name -> NewType | Replace an inherited child's type |
pin | pin VCC | Declare a physical pin |
signal | signal reset | Declare an electrical signal |
trait | trait TraitName | Attach a trait |
import | import Type | Import a type |
for | for x in arr: | Iterate over an array (pragma-gated) |
string | """...""" | Documentation string |
pass | pass | Empty placeholder |
Statements within a block are order-independent — the compiler resolves the full graph, not a sequence of operations.
Show full SKILL.md (355 more words)Show less
Type System
Interfaces (connectable with ~ or ~>)
| Type | Children / Parameters | Purpose |
|---|---|---|
Electrical | (single node) | Raw electrical connection point |
ElectricPower | .hv, .lv (Electrical); .voltage, .max_current | Power rails |
ElectricLogic | .line (Electrical), .reference (ElectricPower) | Digital signals with voltage context |
ElectricSignal | .line (Electrical), .reference (ElectricPower) | Analog signals |
I2C | .scl, .sda (ElectricLogic); .frequency, .address | I2C bus |
SPI | .sclk, .mosi, .miso (ElectricLogic); .frequency | SPI bus |
UART / UART_Base | .tx, .rx (ElectricLogic); flow control lines | Serial |
I2S | audio data bus lines | Digital audio |
DifferentialPair | .p, .n | Differential signals |
USB2_0 / USB3 / USB2_0_IF | USB data + power | USB interfaces |
CAN_TTL | CAN bus lines | CAN bus |
SWD / JTAG | debug lines | Debug interfaces |
Ethernet / HDMI / RS232 / PDM / XtalIF / MultiSPI | protocol-specific | Other protocols |
Modules (instantiable with new)
| Type | Children / Parameters | Designator |
|---|---|---|
Resistor | .unnamed[0..1]; .resistance, .max_power | R |
Capacitor | .unnamed[0..1], .power; .capacitance, .max_voltage, .temperature_coefficient | C |
CapacitorPolarized | polarized variant of Capacitor | C |
Inductor | .unnamed[0..1]; .inductance | L |
Fuse | .unnamed[0..1]; .trip_current, .fuse_type | F |
Diode | .anode, .cathode; .forward_voltage, .current | D |
LED | .diode; .brightness, .color | D |
MOSFET | .source, .gate, .drain; .channel_type, .gate_source_threshold_voltage | Q |
BJT | .emitter, .base, .collector; .doping_type | Q |
Regulator / AdjustableRegulator | .power_in, .power_out | — |
Crystal | .unnamed[0..1], .gnd; .frequency, .load_capacitance | XTAL |
Crystal_Oscillator | oscillator module | — |
ResistorVoltageDivider | voltage divider circuit | — |
FilterElectricalRC | RC filter | — |
Net | .part_of (Electrical) | — |
TestPoint | .contact; .pad_size, .pad_type | TP |
MountingHole / NetTie | mechanical | — |
SPIFlash | SPI flash memory | — |
Traits (attachable with trait)
has_part_removed, is_atomic_part, can_bridge, can_bridge_by_name, has_datasheet, has_designator_prefix, has_doc_string, has_net_name_affix, has_net_name_suggestion, has_package_requirements, has_single_electric_reference, is_auto_generated, requires_external_usage
Units and Literals
SI-prefixed units: V, mV | A, mA | ohm, kohm, Mohm | F, uF, nF, pF | Hz, kHz, MHz, GHz | s, ms | W, mW
Number formats: decimal (3.3), scientific (1e-6), hex (0x48), binary (0b1010), underscore-separated (1_000_000)
Booleans: True, False
Invariants
- Type-safe connections:
~and~>should connect matching interface types.ElectricPower ~ I2Cis a type mismatch (enforcement is being strengthened). - Pragma gates syntax: using
~>,for,trait, or<>without the matching pragma is a compile error. - Tolerances on passives:
resistance = 10kohm(zero tolerance) matches no real parts. Always use+/- N%. - ElectricLogic needs a reference: logic signals require a power reference for voltage context. Set
signal.reference ~ power_rail. - Order independence: statements within a block are not sequentially executed. The solver resolves the full graph.
- No procedural logic: no
if,while,return, functions, classes, or exceptions.
© atopile, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 1 other file in .claude/skills/ato-language of atopile/atopile.
- SKILL.md
- EXTENSION.md
Open the folder on GitHubat commit 619eda7
Compare with similar skills
Ato Language next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Ato Language this skillatopile/atopile | 4k | — | ~3.5k | Automated safety check: Pass | MIT | |
| ConnectComposioHQ/awesome-claude-skills | 77k | 3 repos | ~987 | Automated safety check: Pass | None | |
| Node Connectopenclaw/openclaw | 392k | — | ~1.6k | Automated safety check: Pass | MIT | |
| Semantic Liststhedaviddias/Front-End-Checklist | 74k | — | ~504 | Automated safety check: Pass | MIT | |
| Dsl Vm Reversesickn33/agentic-awesome-skills | 47k | 1 repos | ~2.4k | Automated safety check: Pass | MIT | |
| Openwork Connectdifferent-ai/openwork | 24k | — | ~370 | Automated safety check: Pass | Custom licence |
Similar skills
Node Connect
openclaw/openclaw
Diagnose OpenClaw Control UI browser and native Android, iOS, or macOS node connection failures across route, auth, pairing, QR/setup-code, and reconnect states.
Semantic Lists
thedaviddias/Front-End-Checklist
A skill your agent uses when reviewing rendered HTML, interactive components, or design-system patterns related to Use semantic list elements.
Dsl Vm Reverse
sickn33/agentic-awesome-skills
Reverse JavaScript-based custom DSL/VM interpreters and risk-control engines: identify IIFE/switch-based opcode dispatch, extract opcode tables, and capture runtime semantics.
Openwork Connect
different-ai/openwork
Search and use the skills, MCP connections, and connected services available through the user's OpenWork organization.
Semantic Versioning
sickn33/agentic-awesome-skills
Automate versioning and changelog generation using semantic versioning principles.
More from atopile/atopile
All 19 skills in this repoCompiler
atopile/atopile
How the atopile compiler builds and links TypeGraphs from .ato (ANTLR front-end → AST → TypeGraph → Linker → DeferredExecutor), plus the key invariants and test entrypoints.
Domain Layer
atopile/atopile
Instructions for electronics-specific logic and build processes: netlists, PCBs, build steps, and exporters.
Fabll
atopile/atopile
How FabLL (faebryk.core.node) maps Python node/trait declarations into the TypeGraph + instance graph, including field/trait invariants and instantiation patterns.
Faebryk
atopile/atopile
How Faebryk's TypeGraph works (GraphView + Zig edges), how to traverse/resolve references, and how FabLL types/traits map onto edge types.
Graph
atopile/atopile
How the Zig-backed instance graph works (GraphView/NodeReference/EdgeReference), the real Python API surface, and the invariants around allocation, attributes, and cleanup.
Library
atopile/atopile
How the Faebryk component library is structured, how F.py is generated, and the conventions/invariants for adding new library modules.
Questions about Ato Language
What does Ato Language do?
Reference for the .ato declarative DSL: type system, connection semantics, constraint model, and standard library. Ato Language is an agent skill from atopile/atopile.ato declarative DSL: type system, connection semantics, constraint model, and standard library.
When should I use Ato Language?
Ato Language fits situations like: reviewing .ato code.
How do I install Ato Language in Claude Code?
Run `npx skills add atopile/atopile --skill ato-language -a claude-code`. Or copy the skill folder (.claude/skills/ato-language in atopile/atopile) into .claude/skills/ato-language in your project. Claude Code loads it when a task matches its description.
How do I install Ato Language in Codex?
Run `npx skills add atopile/atopile --skill ato-language -a codex`. Or copy the skill folder (.claude/skills/ato-language in atopile/atopile) into .agents/skills/ato-language in your project. Codex loads it when a task matches its description.
Can I use Ato Language in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add atopile/atopile --skill ato-language -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/ato-language, .gemini/skills/ato-language, .github/skills/ato-language and .opencode/skills/ato-language in your project.
What does Ato Language need to run?
SKILL.md names no scripts, command-line tools or credentials: Ato Language is instructions for the agent only.
Does Ato Language access the network?
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Is Ato Language safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
What licence does Ato Language use?
Ato Language is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Ato Language use?
About 3.5k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
What are the alternatives to Ato Language?
Skills that share tags, products or a category with Ato Language: Connect (ComposioHQ/awesome-claude-skills, 77k stars), Node Connect (openclaw/openclaw, 392k stars), Semantic Lists (thedaviddias/Front-End-Checklist, 74k stars) and Dsl Vm Reverse (sickn33/agentic-awesome-skills, 47k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Ato Language?
atopile (a GitHub organization) maintains it in atopile/atopile, which has 3,979 GitHub stars. The repository holds 19 skills in this directory. The repository was last updated on June 13, 2026.
Source: atopile/atopile on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.