Arcable: The language that fits your coding style/grammar

bored duck — Sun, 17 May 2026 21:16:18 +0000

Downloads:

Arcable

Arcable is a programming language for writing C++-targeted programs in a style
that can feel Python-like, C-like, assembly-like, or a practical hybrid of
those forms. Arcable source files use the .arc extension.

The reference implementation is a small compiler written in C. It lowers
Arcable code into temporary C++, invokes clang++, deletes the temporary
<basename>.arcable.cpp file, and leaves the compiled application behind.

Build

cmake -S . -B build
cmake --build build --config Debug

This builds both arcable.exe and the compatibility command acomp.exe.
On Windows it also builds install.exe, a GUI installer that contains the
Arcable command binaries, LSP, source snapshot, and VS Code extension files.

Install

Install the command line tools, language server helper, and local VS Code
extension:

.\build\Debug\install.exe

The GUI installer extracts arcable.exe and acomp.exe to
%LOCALAPPDATA%\Arcable\bin, writes the LSP and bundled source/support files
under %LOCALAPPDATA%\Arcable, installs the VS Code extension into the user's
VS Code extension folder, and sets ARCABLE_HOME, ARCABLE_TOOLS,
ARCABLE_LSP, and the user PATH.

You can also run the script installer directly:

powershell -ExecutionPolicy Bypass -File .\tools\install.ps1

The installer builds the project, copies acomp.exe and arcable.exe to
%LOCALAPPDATA%\Arcable\bin, adds that directory to your user PATH, copies
tools\arcable_lsp.py to %LOCALAPPDATA%\Arcable\tools, and sets
ARCABLE_HOME, ARCABLE_TOOLS, and ARCABLE_LSP for editor integrations.

Open a new terminal after installing, then run:

acomp .\examples\python_like.arc -o .\build\Debug\python_like.exe -- -Wall

Use -SkipVSCodeExtension if you only want the CLI and LSP files installed.

Compile A Program

.\build\Debug\arcable.exe .\examples\python_like.arc -o .\build\Debug\python_like.exe -- -Wall

Everything after -- is forwarded to clang++. On Windows, arcable
automatically initializes the Visual Studio Build Tools environment before
launching Clang when it can find vcvars64.bat. Set ARCABLE_VCVARS64 to a
custom vcvars64.bat path if Visual Studio is installed somewhere unusual.

Language Styles

Python-like:

def main() -> int:
    message: string = "hello"
    print(message)
    return 0

C-like:

int main() {
    print("hello");
    return 0;
}

Assembly-like:

.var value int 41
add value 1
print value
ret 0

Hybrid styles are allowed when they are unambiguous. For example, Python-style
def and print can be mixed with C-style braces:

def main() {
    print("hello")
}

Imports:

import <math.h>
from <stdint.h> import *

#include <math.h>
import "my_header.hpp";

.import <math.h>
%include "my_header.hpp"

Import targets become C++ #include lines in the generated file. They must use
angle brackets for system headers or quotes for local headers.

Smoke Tests

powershell -ExecutionPolicy Bypass -File .\tests\run_smoke.ps1

Language Server

Arcable includes a dependency-free Language Server Protocol server:

python .\tools\arcable_lsp.py

Configure your editor's LSP client to launch that command for .arc files. The
server provides:

diagnostics for malformed imports, block syntax, braces, and assembly-like instructions
completions for Arcable keywords, C++ keywords/types/standard headers, imports, and assembly-like instructions
hover text for common Arcable and C++ language forms
full-document sync for unsaved editor buffers

For VS Code, use any generic LSP client extension and set the server command to:

{
  "command": "python",
  "args": ["C:/Users/devel/Downloads/adaptablecpp/tools/arcable_lsp.py"],
  "filetypes": ["arc"]
}

VS Code Extension

VS Code does not need a separate LSP client for Arcable. This repo includes
a local extension with syntax coloring, diagnostics, quick fixes, hover, and
dropdown completions for .arc files.

Install it:

powershell -ExecutionPolicy Bypass -File .\tools\install_vscode_extension.ps1

Then reload VS Code and open a .arc file. The extension contributes the
Arcable language mode for .arc files and runs entirely inside VS Code.

The extension lives in vscode-extension/ if you want to inspect or edit it.

History

Arcable started under the name AdaptableCPP. That name described the first
implementation idea: a compiler that adapted different code styles into C++.

The name was dropped because the project had grown beyond being just an
"adaptable C++ compiler." Once .arc files, a syntax model, diagnostics,
imports, editor support, and reusable language rules existed, it made more
sense to treat it as its own programming language. Arcable is shorter,
works better as a language name, and leaves room for the language to evolve
without sounding like only a C++ wrapper.

Essential.CDN; Get the CDN that supports you

bored duck — Sun, 08 Feb 2026 16:44:17 +0000

About Essential.CDN

Essential.CDN is the place to run scripts straight from the internet.
Add packages to your website using Cloudflare’s global hosting network — less downtime, more building, more shipping.

Why download scripts when that’s clearly in the past?

JavaScript deserves a fast, reliable CDN that actually supports you.

Pick Essential.CDN for your JS tasks.

Go to https://essentialcdn.fluidity.workers.dev/

How to support Essential.CDN

Let us grow; Post about us on X or Facebook!

DEV Community: bored duck