C⏚ v2.0.0Updated 2026-05-12·Getting started

Install

Two ways to get C⏚ on your machine. The VS Code extension is the supported editor surface; the standalone JAR is for CI, headless scripting, and editor integrations of your own.

VS Code and CLI backed by the same language server

Both are built around the same language-server JAR and the same core compiler pipeline. Packaging differs; the language and generated outputs match for the same tool version.

Requirements

VS Code extension: VS Code plus Java 17 or newer on PATH.
Standalone JAR / CLI: Java 17 or newer on PATH.

Project layout

The compiler expects package names, file names, and folder paths to agree:

A file declaring package com.example; should live under <src-root>/com/example/.
The file base name should match the top-level entity it defines. Example: task Counter normally lives in Counter.cg.
Imports use the fully-qualified entity name, such as import com.example.Counter;.

Minimal example:

my-project/
  src/
    com/
      example/
        Counter.cg
        Counter_test.cg

If you skip this layout, imports and top-level entity discovery may fail even when the code itself is valid.

See Project layout for the stricter rules, recommended repository shape, and common failure modes.

VS Code extension

The fastest setup. The extension bundles its own cg-language-server.jar, so the main external requirement is a Java 17 or newer runtime on PATH.

From the portal (VS Code)

The extension is distributed from the downloads portal — log in, download the latest neosyn-cg-X.Y.Z.vsix, and install it from VS Code:

code --install-extension neosyn-cg-X.Y.Z.vsix

Or, in VS Code: Extensions view → … menu → Install from VSIX… → pick the file. Reload the window (Developer: Reload Window) so the language server picks up.

From Open VSX (VSCodium, Cursor, …)

Editors that use the Open VSX registry can install directly:

ovsx get neosyn.neosyn-cg        # or search "Neosyn C⏚" in the Extensions view

(Stock VS Code uses the Microsoft Marketplace, where the extension is not yet published — use the portal .vsix above.)

Verify

Open any .cg file (or paste the snippet from the Quick tutorial. You should see syntax highlighting and a Neosyn: Fast Simulation (Bytecode) play-icon in the editor title bar. Run it: if the bytecode simulator prints to the Output → Neosyn C⏚ channel, the install is good.

Licensing

The language server is a commercial, license-gated component (a 14-day trial is available). The first time you use it you provide a license file tied to your machine:

Run Neosyn: Show Machine Fingerprint from the command palette (or the licensing page of the portal) to get your machine fingerprint.
On the portal, generate a license for that fingerprint and download the license file.
Run Neosyn: Install License File… and select it (it is stored at ~/.neosyn/cg.license). Neosyn: Open License Portal jumps to the portal directly.

Without a valid license (or trial), the server starts but refuses to compile or simulate. This applies to the CLI JAR too — it reads the same ~/.neosyn/cg.license.

Standalone CLI

The language-server JAR runs as a long-lived LSP server (for editor integrations) and as a one-shot CLI (for scripting and CI). The CLI is the most direct way to drive the compiler and is the best reference surface when you need explicit flags and reproducible commands.

See CLI reference for the command-oriented version of this section.

Get the JAR

The full cg-language-server.jar ships inside the extension .vsix (from the portal). Grab it from an installed extension:

ls ~/.vscode/extensions/neosyn.neosyn-cg-*/server/cg-language-server.jar

It is the same license-gated jar the editor uses — the CLI reads the same ~/.neosyn/cg.license (see Licensing above).

!!! note "Building the open-source compiler" The Verilog-only, MPL-licensed compiler is open source at github.com/Neosyn-Logic/cg-compiler — a subset of the commercial toolchain (no VHDL, no bytecode Fast Sim, no license gate). Build it from that repo if you want the OSS build; the full jar above comes from the portal.

Sanity check

java -jar cg-language-server.jar --version

This should print a version string. If you get UnsupportedClassVersionError, your java is too old. Run java -version and upgrade to 17 LTS or newer.

CLI surface

Command	Alias	Purpose
`simulate`	`sim`	Run the bytecode simulator on a `.cg` file
`generate`	`gen`	Emit synthesizable Verilog or VHDL
`generate-ir`	`ir`	Dump the internal IR (XMI) for inspection

Common flags: --entity <name> selects the top-level entity when there is more than one in scope. --target verilog|vhdl switches the HDL backend (default Verilog). --output <dir> overrides the output directory. --help and --version work everywhere.

Defaults worth knowing:

simulate writes a VCD by default.
simulate stops at the tool's default cycle cap unless the test terminates earlier.
generate writes to verilog-gen/ or vhdl-gen/ unless --output is supplied.

A typical end-to-end invocation:

java -jar cg-language-server.jar simulate Counter_test.cg
java -jar cg-language-server.jar generate Counter.cg --target verilog

The first runs the cycle-accurate sim and, by default, writes a VCD at the project root (named after the top-level entity). The second emits Verilog under verilog-gen/ at the project root, preserving the source's package path.

Walk through the Quick tutorial to write your first counter, simulate it, and generate Verilog. About ten minutes end to end.