jaseci-labs/jac

The Jac Programming Language -- The language for any human or AI looking to use one language for everything

What it solves

Jac addresses the fragmentation of modern full-stack development, where developers must manage multiple languages (TypeScript, Python, SQL, etc.), package managers, and configuration files (YAML, Dockerfile) to build a single application. This fragmentation creates "glue code"—serializers, ORM models, and API clients—that is not checked by any single compiler, leading to bugs and high maintenance overhead.

How it works

Jac is a "synechic" and "topokinetic" programming language that uses a single Python-like syntax to compile to Python bytecode, JavaScript, and native machine code.

  • Synechic (Continuity): It provides a continuous medium across the frontend, backend, and native tiers. One compiler checks the entire stack, meaning a field rename in the data model triggers a compile error across all tiers instead of a production failure.
  • Topokinetic (Motion): It uses Object-Spatial Programming where data is a persistent topology of nodes and edges. "Walkers" carry computation through this graph, and persistence is built directly into the language rather than requiring an external database or ORM.
  • Polypiler: The jac binary acts as a complete toolchain, bundling a private CPython, Bun (JS runtime), LLVM, and a Kubernetes deployer, eliminating the need for separate installations of interpreters or compilers.

Who it’s for

Jac is designed for humans and AI agents to build full-stack applications together. It is particularly useful for developers who want to reduce boilerplate glue code and for AI coding agents that benefit from a single, type-checked codebase that fits within a context window.

Highlights

  • Unified Toolchain: A single binary replaces the Python interpreter, JS runtime, C compilers, and package managers.
  • AI Integration: LLM calls are treated as typed function calls where the compiler generates the prompt from the function signature and enforces the return type.
  • Gradual Borrow Checking: Allows developers to move from fully managed code to zero-reference-counting native artifacts using own and borrow annotations.
  • Zero-Glue Full-Stack: Automatically generates API endpoints, route tables, and migrations.
  • Agent-Ready: Includes a built-in MCP server and exportable "Agent Skills" to integrate directly with AI coding tools like Claude Code and Cursor.

Related

  • Project
    BeaconBay/ck

    ck is a Rust‑based CLI/TUI tool that builds local embeddings of source code and lets you search by meaning (semantic search) as well as by traditional regex. It supports incremental indexing, multiple embedding models, AI‑agent integration via an MCP server, and outputs results in JSON/JSONL for automation.

  • Project
    opensolon/solon-ai

    A full-scenario Java AI development framework for building LLM applications, RAG knowledge bases, and multi-agent systems with native integration into the Java ecosystem.

  • Project
    limecloud/lime

    An open-source full-stack desktop AI agent that integrates coding, terminal operations, and multimodal research into a single visual workspace to execute complex tasks.

  • Project
    deepset-ai/haystack

    An open-source AI orchestration framework for building production-ready RAG systems, autonomous agents, and LLM applications in Python.

  • Project
    typedef-ai/fenic

    A semantic DataFrame engine that integrates LLM operators into a typed query model to turn unstructured data into reusable, inspectable pipelines.