Silc — Build VDC Software with Intent

Silc (pronounced silk) is a generic intent language and compiler for real-time 3D, operational applications, and data pipelines. Its lead direction is Virtual Design and Construction (VDC): software that connects interactive project environments with the dashboards, data, and automation around them.

Write a concise .silc program describing the domain. Silc validates the intent, selects the right engines, and synthesizes the runtime.

VDC foundations: Browser-native model walkthroughs, site visualization, and digital-twin building blocks
Real-time 3D: WebGPU scenes with entities, assets, physics, cameras, and AI
Operational apps: Dual-surface web + terminal tools from one component tree
Data and AI: Scrape, extract, embed, persist, and assist without framework glue

VDC is the lead vertical, not a boundary. The same language can build games, simulations, internal tools, assistants, and standalone data pipelines.

Silc is open source from ThoughtPivot.

.silc intent  →  Rust compiler  →  Bun · CPython · Go workers  →  mmap IPC + UDS

Why VDC

VDC software rarely fits inside one framework. A useful construction workflow may combine an interactive project model, a field dashboard, persistent project records, document extraction, and automation. Teams commonly bridge dedicated 3D engines, web stacks, scripts, services, and databases to deliver one experience.

Silc is designed around that full shape:

game:: declares browser-native real-time 3D scenes and simulations.
ui:: declares operational interfaces synthesized for web and terminal.
Pipeline operations declare ingestion, extraction, local AI, and persistence.
One compiler owns the generated Bun, CPython, and Go runtime beneath them.

Real-time game programs and dual-surface app programs are distinct roots today; Silc does not yet embed a ui:: application inside a game:: scene. They share the language, compiler, runtime ownership model, and generic primitives—not a single mixed source tree.

Today, Silc ships the generic primitives behind these workflows. Interactive GLTF scenes, physics, cameras, dual-surface applications, CRUD resources, document extraction, scraping, and local AI pipelines are available now. Native BIM semantics, construction-platform connectors, multi-user coordination, live sensor ingestion, and complete production digital twins are directional use cases—not claims about current functionality.

The Silc thesis

Modern AI coding workflows still spend too much of their budget on decisions that should be deterministic: framework selection, UI parity, persistence, worker boundaries, IPC, asset handling, and runtime setup.

Agents and humans repeatedly invent React trees, Python services, Go stores, package manifests, engine scaffolding, and integration glue. That burns tokens, creates drift, and blurs the line between domain intent and runtime substrate.

Authors and agents should declare intent; the compiler should own substrate. Deterministic routing, closed operation registries, and compiler-synthesized mechanics let models spend tokens on project meaning—spaces, equipment, workflows, records, simulations, and decisions—while Silc handles the rest.

What you can build

VDC and construction

Model walkthroughs and coordination environments: Load GLTF project assets into browser-native WebGPU scenes with cameras, lighting, collision, navigation, and overlays.
Digital-twin foundations: Combine interactive spatial context with application state, persistence, telemetry, and compiler-owned runtime services.
Site logistics and sequencing: Compose reusable entities and prefabs for equipment, access paths, temporary works, alternatives, and phases.
Field and project operations: Build dashboards, inspection tools, issue lists, document ledgers, and local assistants on the same intent model.
Safety and training simulations: Use the real-time kernel for interactive orientation, scenario rehearsal, and spatial communication.

These are target workflows built from generic primitives. Silc does not encode construction-specific behavior into the compiler; construction vocabulary and integrations belong in authored programs and reusable domain packages.

Real-time 3D, simulations, and games

Declare scenes, imported assets, prefabs, entities, physics, navigation, cameras, materials, effects, and gameplay systems. The compiler synthesizes a Babylon.js WebGPU runtime without making Babylon, Unity, or Unreal the authoring surface.

The namespace is currently named game:: because the runtime uses proven game engine patterns. It is the generic real-time 3D subject for VDC experiences, digital-twin foundations, simulations, training tools, and entertainment games.

Inspired by the big three:

Pattern	Inspiration	Silc surface
Entity hierarchy	Godot node tree	Nested `game::entity` with parent/child transforms
Signals and groups	Godot signals	`game::signal`, `game::group`
Prefabs and data assets	Unity prefabs + ScriptableObjects	`game::prefab`, `game::spawn`, `game::data` + `:ref`
Mode / Pawn / Controller	Unreal gameplay framework	`game::mode`, `game::pawn`, `game::controller`
Abilities	Unreal GAS	`game::ability` with cooldowns, costs, and cue children
Asset bake	Unity import pipeline	CPython → `public/baked/` (PBR textures, collision hulls)

Dual-surface applications

Operational tools that work everywhere. One component tree compiles to both a React/Tailwind web app and an OpenTUI terminal interface. Teams get a browser dashboard and SSH access to the same workflows.

CRUD apps with zero boilerplate. Declare a contract and a resource; Silc synthesizes SQLite tables, HTTP APIs, and form bindings. No Express routers, ORM setup, or migration scripts.

Local assistants grounded on project data. Add ui::chat with live query context and a persona. The compiler provisions silclm and connects it to the application's resources.

Data and AI pipelines

Use scrape::page, scrape::site, doc::extract, tensor::tokenize, tensor::infer, and llm::complete to express data movement and processing without naming the implementation framework. Silc routes work to its compiler-owned engines and synthesizes persistence where supported.

The pitch is simple: fewer tokens per working system. Engine choice, dual-surface parity, persistence, asset handling, and IPC are compiler decisions—not prompt decisions.

How it looks in practice

Examples below are Silc 0.4.0 source. GitHub fences use raku for highlighting only. The surface is Raku-inspired, not Raku-compatible. Source files are .silc only.

1. A VDC project walkthrough

This compact scene uses the same generic real-time 3D primitives as a game, but applies them to a browser-native project environment. Replace the GLTF path with an exported project model; domain-specific BIM semantics remain outside the compiler.

#!/usr/bin/env silc
@version("0.4.0")

game ProjectWalkthrough {
    game::scene(
        :title("Project Walkthrough"),
        :renderer(webgpu),
        game::asset(
            :name("project_model"),
            :path("public/assets/project.glb"),
            :kind(gltf)
        ),
        game::entity(
            :name("ProjectModel"),
            game::mesh(:asset("project_model"))
        ),
        game::entity(
            :name("Ground"),
            :y(0),
            game::mesh(:shape(plane), :size(80), :color("#aeb8ae")),
            game::collider(:shape(plane), :size(80))
        ),
        game::entity(
            :name("Sun"),
            game::light(:kind(directional), :intensity(1.1))
        ),
        game::prefab(
            :name("Viewer"),
            game::mesh(:shape(capsule), :size(1.8)),
            game::collider(:shape(capsule), :size(1.8)),
            game::movement(:style(first_person), :speed(4.5)),
            game::pawn()
        ),
        game::spawn(
            :prefab("Viewer"),
            :x(0),
            :y(1),
            :z(6),
            :as_pawn
        ),
        game::mode(
            :id("walkthrough"),
            :possess("Viewer")
        ),
        game::controller(
            :scheme(wasd_mouse)
        ),
        game::camera(
            :mode(first_person),
            :follow(pawn)
        ),
        game::environment(
            :fog_density(0.002),
            :fog_color("#d8dde2"),
            :sky_color("#9fb6cc"),
            :exposure(1.0)
        )
    )
}

You declared: project asset, environment, viewer, collision, controls, and camera intent. Silc synthesizes: asset loading and baking, Babylon WebGPU scene setup, first-person movement, input, physics, and the browser host.

2. A dual-surface notes app

What silc init scaffolds — a form, an app route table, and an optional scorer. Dual-surface web/terminal serving and SQLite persistence are synthesized.

@version("0.4.0")

contract Note {
    has Str $.author;
    has Str $.text;
}

component HomePage {
    has state Str $.author = "";
    has state Str $.text = "";

    method render() {
        ui::page(
            :app_bar(ui::app_bar(:title("My Silc App"))),
            :side_panel(ui::side_panel(
                ui::nav_item(:label("Home"), :to("/"), :active)
            )),
            ui::stack(
                ui::heading(:text("Leave a note"), :level(2)),
                ui::form(:on(submit(on_submit)),
                    ui::text_input(:field(author), :label("Author")),
                    ui::textarea(:field(text), :label("Note")),
                    ui::toolbar(
                        ui::button(:label("Submit"), :variant(primary), :submit)
                    )
                )
            )
        )
    }

    method on_submit() {
        submit();
    }
}

app MyApp {
    route "/" => HomePage;
}

processor NoteScorer {
    method analyze(Note $note) {
        $note.text ==> text::score()
    }
}

You declared: schema, UI, routes, scoring intent. Silc synthesizes: React web + OpenTUI terminal, POST /submit, Go/SQLite sink, Bun ingress, and mmap staging between workers.

3. Resource CRUD + grounded local chat

From examples/inventoryApp — capability-style resources become HTTP CRUD; chat is grounded on a live inventory snapshot.

contract InventoryItem {
    has Str $.id;
    has Str $.name;
    has Str $.category;
    has Str $.location;
    has Str $.quantity;
    has Str $.reorder_level;
    has Str $.notes;
}

contract ChatRecord {
    has Str $.prompt;
    has Str $.reply;
}

resource InventoryItems for InventoryItem {
    query list;
    mutation create;
    mutation update;
    mutation delete;
}

component BrowsePage {
    has state Str $.category_filter = "All";
    query $.items = InventoryItems.list();

    method render() {
        ui::page(
            :app_bar(ui::app_bar(:title("Inventory"))),
            :side_panel(ui::side_panel(
                ui::nav_item(:label("Browse"), :to("/"), :active),
                ui::nav_item(:label("Admin"), :to("/admin")),
                ui::nav_item(:label("Assistant"), :to("/assistant"))
            )),
            ui::stack(
                ui::section(
                    :title("Stock browser"),
                    :description("Filter by category, or ask the Assistant about live inventory.")
                ),
                ui::table(
                    :rows($.items),
                    :columns(["name", "category", "location", "quantity", "reorder_level", "notes"]),
                    :empty_text("No inventory items yet. Add some in Admin."),
                    :filter_field(category_filter),
                    :filter_column("category"),
                    :sortable,
                    :searchable
                )
            )
        )
    }
}

# … AdminPage omitted …

component AssistantPage {
    has state Str $.prompt = "";
    query $.items = InventoryItems.list();

    method render() {
        ui::page(
            :app_bar(ui::app_bar(:title("Inventory Assistant"))),
            ui::chat(
                :value($.prompt),
                :context($.items),
                :persona("You are the Inventory Assistant for this Silc inventory app, built on silclm."),
                :placeholder("Which items are below reorder level?"),
                :on(send(on_send))
            )
        )
    }

    method on_send() {
        Assistant.complete();
    }
}

app InventoryApp {
    route "/" => BrowsePage;
    route "/admin" => AdminPage;
    route "/assistant" => AssistantPage;
}

processor Assistant {
    method complete(ChatRecord $record) {
        $record.prompt ==> llm::complete()
    }
}

You declared: domain model, CRUD capabilities, browse/admin/assistant routes, and a local completion processor. Silc synthesizes: /api/inventory_items CRUD, dual-surface UI, silclm provisioning, and persistence for chat/processor results.

4. Real-time 3D game: first-person shooter

From examples/arenaGameApp — a cinematic FPS with weapons, hostile AI, and modular level geometry. It exercises the same reusable scene, asset, physics, camera, and entity kernel available to VDC and simulation programs.

@version("0.4.0")

game Arena {
    game::scene(:title("MEGASTRUCTURE"), :renderer(webgpu), :target_fps(90),
        game::data(:name("WalkDefault"), :speed(5.5)),
        game::data(:name("VanguardData"), :damage(16), :fire_rate(9), :magazine(30)),

        game::prefab(:name("Player"),
            game::mesh(:shape(capsule), :size(1.8)),
            game::collider(:shape(capsule), :size(1.8)),
            game::movement(:style(first_person), :ref("WalkDefault")),
            game::attribute(:name("health"), :value(100), :max(100)),
            game::pawn()
        ),

        game::spawn(:prefab("Player"), :x(0), :y(1), :z(0), :as_pawn),
        game::weapon(:name("VanguardAR"), :slot(1), :fire_mode(hitscan), :ref("VanguardData")),
        game::mode(:id("arena"), :possess("Player")),
        game::controller(:scheme(wasd_mouse)),
        game::camera(:mode(first_person), :follow(pawn))
    )
}

You declared: player prefab, weapon stats, spawn point, camera mode. Silc synthesizes: Babylon WebGPU scene, physics colliders, input handling, HUD, and Go/SQLite persistence for saves and analytics.

5. Pipeline-only: scrape → embed → store

From examples/pipelineApp — no UI app required. One intent file becomes a Bun/CPython/Go ingestion graph.

@version("0.4.0")

subset Uri of Str where { .starts-with("http") }
subset Emb384 of Vec[num32; 384];

contract ArticlePayload {
    has UUID $.id;
    has Uri $.url;
    has Str $.raw_content;
    has Emb384 $.vector_embedding;
}

service ArticleIngress {
    method fetch_article() {
        target_url
            ==> scrape::page(:js(false))
            ==> scrape::extract(:into(ArticlePayload))
    }
}

processor Embedder {
    method embed(ArticlePayload $article) {
        $article.raw_content
            ==> tensor::tokenize(:model("minilm-l6-v2"))
            ==> tensor::infer(:prefer(CPU))
    }
}

Run with:

silc run main.silc --input-json '{"url":"https://example.com/"}'

Design principles

Intent over substrate. Authors never write serve(), invent React or OpenTUI trees, declare sinks, or wire ipc::* / store::* pipelines.
Deterministic compilation. Tier 1/2 routing cites engine strengths; every decision has provenance.
Scalable monolith. One cohesive .silc intent model compiles into a supervised cluster of specialized workers (Bun, CPython, Go) that share memory-mapped slots. You author one program; the runtime is polyglot and co-located — not a sprawl of hand-maintained microservices.
AI-native, compiler-first. Models emit .silc. The compiler is the validation oracle. Assist explores corpus and checks drafts without stuffing the entire authoring contract into the root prompt.
Pinned, owned runtimes. Bun, CPython, and Go are checksum-verified into ~/.silc/runtimes/. Authors and agents do not choose engines.

Quick start

cargo install --path crates/silc --force

silc init myapp
cd myapp
silc build main.silc   # validate + codegen
silc main.silc              # run web by default
silc main.silc --terminal   # also attach OpenTUI (+ telnet)

# web:      http://127.0.0.1:18088  (override SILC_HTTP_PORT)
# terminal: silc main.silc --terminal  (or SILC_TERMINAL=1)
# fallback: telnet 127.0.0.1 18023 when --terminal is set

silc init writes main.silc, AGENTS.md, .gitignore, and a runtime lock, then provisions pinned engines on first use.

Example projects

App	Purpose	Web	Terminal
`examples/arenaGameApp/`	Real-time WebGPU kernel: assets, environments, physics, AI, and modular scenes	18140	—
`examples/platformGameApp/`	2D platformer built from reusable sprite, tilemap, interaction, and movement primitives	18140	—
`examples/chatApp/`	Multi-session local chat via silclm	18090	18091
`examples/inventoryApp/`	CRUD + browse/admin + grounded assistant	18096	18097
`examples/scraperApp/`	URL + depth crawl; results table + summaries	18110	18111
`examples/pipelineApp/`	Scrape → MiniLM/ONNX → SQLite	—	—
`examples/blogApp/`	Seeded blog; year/month filters; admin modal CRUD; grounded search	18120	18121
`examples/dataExtractorApp/`	File upload + `doc::extract` → documents ledger	18130	18131

See examples/README.md.

What ships today (0.4.0)

Silc is pre-1.0. Release 0.4.0 makes the product rule explicit: authors declare intent; the compiler synthesizes runtime mechanics (ADR-009).

Applications

Every UI app synthesizes both surfaces automatically — compiler-owned ui::web (React/Tailwind) and ui::terminal (OpenTUI). Authors declare routes only; they never write method serve(), ui::web, or ui::terminal as program operations. The full UI primitive catalog (39 dual-surface builtins), closed prop enums, and agent rules live in crates/silc/templates/AGENTS.md.

Shipped for apps:

Parse → validate → deterministic Tier 1/2 route → codegen → supervised run
Declaration-based component / resource Name for Contract / app routes
Dual-surface UI synthesized from app (web + terminal)
Generic resource CRUD over SQLite
silc init scaffold and experimental silc assist
Compiler-owned Bun / CPython / Go under ~/.silc/runtimes/

Real-time 3D

The WebGPU-only game subject is Silc's current generic real-time 3D surface. You declare intent with game::* nodes; the compiler synthesizes a Babylon.js runtime. Babylon is the WebGPU adapter, not the authoring surface, and the namespace does not limit the kernel to entertainment games.

What you can declare:

game::scene — root with title, renderer, target FPS
game::entity — transform node with mesh, collider, light children
game::prefab / game::spawn — reusable templates with override props
game::weapon — hitscan, pellet, projectile, or beam fire modes
game::npc / game::perception / game::nav_agent — hostile AI with nav mesh
game::ability — cooldowns, attribute costs, particle/light/impulse cues
game::camera, game::controller, game::hud, game::post_process

Polyglot spine: Real-time 3D programs use the full stack. CPython bakes assets at compile time. Go persists saves, runs, and analytics to SQLite. Bun serves the WebGPU host and handles HTTP for settings and telemetry.

See ADR-012 for the full design.

Executable operations

Author-facing ops that run today:

service::http, text::score, llm::complete, scrape::page, scrape::site, scrape::select, scrape::render, scrape::extract, doc::extract, tensor::tokenize, tensor::infer.

Boundaries

Broader pipeline namespaces (http::*, html::*, numpy::*, pandas::*, …) are stub-only: they parse/route/emit but do not execute
Tensor path is CPU-only MiniLM → exactly 384 normalized num32 values
IPC ABI v1 is schema-tagged JSON in mmap (not typed zero-copy views)
No self-contained silc bundle deployment artifact yet
Assist is experimental; fine-tuned assist weights are not shipped

Authoring contract for agents: crates/silc/templates/AGENTS.md.

Runtime: why Bun, CPython, and Go

You never pick a language — the compiler does. Each engine handles what it does best, and they communicate through shared memory.

Silc does not ask models (or developers) to pick languages. The router assigns work from complementary strengths (ADR-004):

Engine	Role in Silc
Bun	Generated TypeScript: web UI, terminal UI, HTTP ingress, static scrape helpers
CPython	Scoring, local LLM (llama.cpp / silclm), Playwright scrape, ONNX MiniLM, game asset baking
Go	SQLite persistence, HTTP APIs, high-concurrency Colly crawls

Engines are pinned and checksum-verified (Bun 1.2.18, CPython 3.12.12, Go 1.23.6) under ~/.silc/runtimes/. There is no PATH override surface and no author-facing engine picker.

Silc source (.silc)
        │
        ▼
   sil-lexer → sil-parser → sil-core subjects
        │     (Contract · Component · Resource · App · Module · Pipeline · Game)
        ▼
   sil-router   Tier 1 (kind + traits) + Tier 2 (namespaces)
        ▼
   sil-codegen  runnable workers + dual-surface UI lowering + game kernel
        ▼
   silc supervisor
        ├── Bun  (web + terminal + resource HTTP + static scrape)
        ├── CPython (scoring / local LLM / Playwright / ONNX / game bake)
        ├── Go (SQLite / HTTP API / Colly crawl)
        └── sil-ipc mmap slots + UDS

Scalable monolith

A Silc program is a monolith at the intent layer and a supervised polyglot runtime underneath. One file owns the product model. The compiler emits specialized workers that scale within that model — for example, replica pools for CPU-bound scoring — without forcing authors to design a microservice mesh. That is the scalable-monolith shape: cohesive product semantics, partitioned execution, shared contracts.

IPC that stays out of your way

Cross-engine data movement uses ThoughtPivot's Silc Shared Buffer ABI v1 (ADR-001, SILC-IPC-ABI-v1.md):

Data plane: file-backed mmap slots under .runtime/ (default 512 × 16 KiB; larger for pipeline payloads). Magic bytes SILC.
Control plane: small Unix domain socket wakeups (segment_id, offset, len, schema_id).

Payloads stay in shared memory between processor and synthesized persistence. Workers do not retransmit application bodies over HTTP between those stages. ABI v1 carries schema-tagged JSON in the mapped buffer; typed zero-copy field views are a future ABI layer, not a current claim.

AI-native authoring and Silc Assist

Silc is designed so language models author intent programs, not framework scaffolding.

In-app intelligence: llm::complete / ui::chat run on silclm (compiler-pinned local GGUF). Use :context(...) to ground answers on live resource data.
Silc Assist (experimental): silc assist drafts and modifies .silc files with silclm (ADR-008). It auto-retrieves relevant examples and AGENTS.md rules, asks for a complete program via the chat template (stop marker # END), then compile-and-repairs. Creating a file adapts the silc init starter as a skeleton, so the usual run lands on the first attempt in ~6–12s. Repairs escalate cheapest-first: mechanical diagnostics are auto-fixed with no model call, structural ones get an explicit rule, and only the rest fall back to error-targeted corpus search. The slower tool loop is opt-in (--explore). Inference uses a warm silclm worker with Metal GPU offload by default on Apple Silicon.

silc assist "dual-surface notes app with submit" notes.silc
silc assist "refine the form" notes.silc --explore   # optional slower fallback

Assist is Phase 1: useful, bounded, and experimental. A fine-tuned silclm-assist model is reserved but not shipped yet. In-app chat and Assist remain separate products on the same local model family.

Token efficiency, concretely: every framework/engine/persistence decision the compiler owns is a decision the model no longer has to negotiate in context. Compiler diagnostics then act as a hard oracle — accepted programs parse, validate, and route before they run.

Editor support (VS Code / Cursor)

Silc ships a VS Code / Cursor extension that provides syntax highlighting and a Rust language server (sil-lsp) for semantic hover on .silc sources — resource methods, query bindings, contracts and fields, components, props and state, UI primitives, executable ops, keywords, operators, and builtin types.

Install it with the bundled script:

./editors/vscode-silc/install.sh

The script:

Builds sil-lsp in release mode (cargo build -p sil-lsp --release)
Installs npm dependencies and compiles the TypeScript language client
Bundles the host-platform server binary into a VSIX
Installs the extension with the cursor CLI, falling back to code

Requirements: a Rust toolchain, Node.js/npm, and a cursor (or code) CLI on your PATH. In Cursor, you can add the CLI via Shell Command: Install 'cursor' command in PATH. Set SILC_EDITOR_CLI to override CLI detection.

After it finishes, run Developer: Reload Window. Open any .silc file — the language indicator should read Silc, and hovering a symbol should show a Markdown tooltip. To point the editor at a locally built server without reinstalling, set silc.languageServerPath to your target/release/sil-lsp path.

See editors/vscode-silc/README.md for hover coverage, highlighting scopes, and development details.

For AI agents

silc init copies the agent contract into the project:

Edit .silc only — never patch .runtime/
Declare routes; dual-surface serving is synthesized
Prefer components + resources over inventing portal profiles or frameworks
Stay inside the UI catalog and runnable operation set
Validate with silc build; report limits instead of escaping to React/OpenTUI

Development

cargo fmt --all -- --check
cargo check --workspace
cargo test --workspace -- --test-threads=1

CI runs fmt, check, library tests, codegen smoke, dual-surface e2e builds, and concurrent /submit POSTs with SQLite checks.

Versioning

Pre-1.0 SemVer 0.x: breaking language/compiler changes bump the minor. 1.0.0 is reserved for a future stability milestone. Releases use release-plz and Conventional Commits.

Documentation

Doc	Topic
docs/ADR-INDEX.md	Decision index
docs/ARCHITECTURE.md	Subject model and crate layout
docs/intent-vs-subjects.md	Intent authoring vs subject architecture
docs/ADR-001-runtime-and-ipc.md	Engines and IPC
docs/ADR-002-silc-surface-syntax.md	Language surface
docs/ADR-003-declarative-ui.md	Dual-surface UI policy
docs/ADR-004-runtime-strengths.md	Why Bun / CPython / Go
docs/ADR-005-local-llm-complete.md	Local LLM completions
docs/ADR-006-scrape-namespace.md	`scrape::*`
docs/ADR-007-pipeline-feeds.md	`==>` semantics
docs/ADR-008-recursive-silclm-assist.md	Silc Assist
docs/ADR-009-compiler-synthesized-runtime.md	Synthesized UI / persistence
docs/ADR-010-tensor-minilm-pipeline.md	MiniLM embedding pipeline
docs/ADR-011-document-extract.md	`doc::*` upload + extract
docs/ADR-012-webgpu-game-subject.md	WebGPU game kernel
docs/SILC-IPC-ABI-v1.md	Shared buffer ABI
CHANGELOG.md	Release notes

License

Apache-2.0 — see LICENSE.

Maintained by the ThoughtPivot engineering team.

Navigation Menu

Repository files navigation

Silc — Build VDC Software with Intent

Why VDC

The Silc thesis

What you can build

VDC and construction

Real-time 3D, simulations, and games

Dual-surface applications

Data and AI pipelines

How it looks in practice

1. A VDC project walkthrough

2. A dual-surface notes app

3. Resource CRUD + grounded local chat

4. Real-time 3D game: first-person shooter

5. Pipeline-only: scrape → embed → store

Design principles

Quick start

Example projects

What ships today (0.4.0)

Applications

Real-time 3D

Executable operations

Boundaries

Runtime: why Bun, CPython, and Go

Scalable monolith

IPC that stays out of your way

AI-native authoring and Silc Assist

Editor support (VS Code / Cursor)

For AI agents

Development

Versioning

Documentation

License

About

Releases

Packages

Contributors

Languages

Name		Name	Last commit message	Last commit date
.cursor/rules		.cursor/rules
.github/workflows		.github/workflows
assets/brand		assets/brand
crates		crates
docs		docs
editors/vscode-silc		editors/vscode-silc
examples		examples
training		training
.gitignore		.gitignore
Cargo.lock		Cargo.lock
Cargo.toml		Cargo.toml
LICENSE		LICENSE
README.md		README.md
release-plz.toml		release-plz.toml
rust-toolchain.toml		rust-toolchain.toml

Latest commit

History

Folders and files

Repository files navigation

Silc — Build VDC Software with Intent

Why VDC

The Silc thesis

What you can build

VDC and construction

Real-time 3D, simulations, and games

Dual-surface applications

Data and AI pipelines

How it looks in practice

1. A VDC project walkthrough

2. A dual-surface notes app

3. Resource CRUD + grounded local chat

4. Real-time 3D game: first-person shooter

5. Pipeline-only: scrape → embed → store

Design principles

Quick start

Example projects

What ships today (0.4.0)

Applications

Real-time 3D

Executable operations

Boundaries

Runtime: why Bun, CPython, and Go

Scalable monolith

IPC that stays out of your way

AI-native authoring and Silc Assist

Editor support (VS Code / Cursor)

For AI agents

Development

Versioning

Documentation

License

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages