{"id":48948017,"url":"https://github.com/alexprogrammerde/vibelang","last_synced_at":"2026-04-17T18:01:04.567Z","repository":{"id":352005102,"uuid":"1213436519","full_name":"AlexProgrammerDE/vibelang","owner":"AlexProgrammerDE","description":"🍜 PoC coding language where you write code as words and is evaluated by AI on the fly.","archived":false,"fork":false,"pushed_at":"2026-04-17T13:30:11.000Z","size":76,"stargazers_count":0,"open_issues_count":3,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-04-17T13:33:07.688Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/AlexProgrammerDE.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-04-17T11:30:56.000Z","updated_at":"2026-04-17T13:30:15.000Z","dependencies_parsed_at":"2026-04-17T18:00:43.933Z","dependency_job_id":null,"html_url":"https://github.com/AlexProgrammerDE/vibelang","commit_stats":null,"previous_names":["alexprogrammerde/vibelang"],"tags_count":23,"template":false,"template_full_name":null,"purl":"pkg:github/AlexProgrammerDE/vibelang","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AlexProgrammerDE%2Fvibelang","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AlexProgrammerDE%2Fvibelang/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AlexProgrammerDE%2Fvibelang/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AlexProgrammerDE%2Fvibelang/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/AlexProgrammerDE","download_url":"https://codeload.github.com/AlexProgrammerDE/vibelang/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AlexProgrammerDE%2Fvibelang/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31939788,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-17T17:29:20.459Z","status":"ssl_error","status_checked_at":"2026-04-17T17:28:47.801Z","response_time":62,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2026-04-17T18:00:34.106Z","updated_at":"2026-04-17T18:01:04.539Z","avatar_url":"https://github.com/AlexProgrammerDE.png","language":"Go","funding_links":[],"categories":[],"sub_categories":[],"readme":"# vibelang\n\n`vibelang` is a Python-shaped interpreted language where user-defined function bodies are plain language. The interpreter is written in Go, and every function call is executed by a local or remote LLM running through Ollama, `llama.cpp`, or an OpenAI-compatible endpoint.\n\n## What It Does\n\n- Uses indentation-sensitive, Python-like syntax for variables, expressions, loops, and conditionals.\n- Treats every `def` body as natural-language instructions instead of imperative code.\n- Supports AI macros with `macro` definitions and `@macro(...)` expansion syntax, so the model can synthesize real vibelang expressions on the fly.\n- Supports module loading with `import \"./module.vibe\" as module` and `from \"./module.vibe\" import helper`.\n- Supports Python-style default parameter values and keyword arguments for user-defined functions and builtins.\n- Supports Python-style unpacking targets in assignments and `for` loops.\n- Supports inline `* prompt` expressions in assignments, conditions, loops, and standalone statements.\n- Supports leading AI directives such as `@temperature`, `@max_tokens`, `@max_steps`, `@cache`, `@system`, `@tools`, and `@deny_tools` inside function and macro bodies.\n- Evaluates `${...}` prompt placeholders as real vibelang expressions, including indexing and prompt-safe builtins such as `len`, `basename`, or `join_path`.\n- Supports Python-style list and dict comprehensions with optional trailing `if` filters.\n- Supports structural `match` / `case` branching with wildcard, list, dict, and capture patterns plus optional `if` guards.\n- Supports structured AI return types such as `dict{city: string, alerts: optional[list[string]]}` and `tuple[string, int]`, and turns them into tighter JSON schemas for model backends.\n- Constrains helper calls with per-helper JSON schemas, so models see the exact argument names, required fields, and types for each callable tool.\n- Supports deterministic `try` / `except` / `finally` blocks for builtin, tool, and model-call failures.\n- Supports Python-style `assert` statements for deterministic guards and self-checking programs.\n- Supports block-scoped `defer` expressions for LIFO cleanup on normal exit, `break`, `continue`, and errors.\n- Supports Python-like member access for imported modules and dict-shaped values, so `shared.helper()` works naturally.\n- Supports Python-style negative indexing and slicing for lists and strings, plus operand-returning `and`/`or` short-circuit behavior.\n- Lets AI functions call other AI functions through a strict JSON tool-call loop, supports explicit JSON `call_many` batches, and also understands provider-native `tool_calls` responses from Ollama, `llama.cpp`, and OpenAI-compatible backends, including multi-call batches.\n- Rejects direct and indirect recursive AI helper re-entry before it spirals into repeated depth exhaustion, feeds the rejection back into the next model step, and fails fast if the model keeps retrying a rejected helper.\n- Adds opt-in AI result caching, CSV/YAML/TOML helpers, first-class sets, richer dict and list helpers, Python-inspired collection helpers such as `all`, `any`, `reversed`, `flatten`, and `batched`, Markdown rendering, route construction, time parsing and formatting, UUID generation, numeric reducers, structured logging, and OpenTelemetry trace export.\n- Captures surrounding non-function values by value when an AI function is defined, so later mutations do not silently change prompt inputs.\n- Exposes a broader standard library for AI execution, including filesystem, JSON, YAML, path, string, cookies, environment, globbing, HTTP, WebSocket and TCP clients, TCP listeners, time, math, local process helpers, async tasks, channels, channel selection, mutexes, wait groups, route matching, and runtime metrics.\n- Lets one AI body route itself to a different backend with `@provider`, `@model`, `@endpoint`, `@api_key_env`, and `@timeout_ms`, so local Gemma can coexist with remote OpenAI-compatible calls in one program.\n- Starts AI-backed HTTP servers, including ordered route tables, WebSocket upgrades, and Server-Sent Event streaming backed by native channel handles.\n- Serves deterministic static frontend assets, including HTML, JS, CSS, JSON, SVG, and `.wasm`, with correct HTTP content types through `http_static_response` and `mime_type`.\n- Exposes deterministic tool introspection so programs can inspect the live helper catalog through `tool_catalog` and `tool_describe`.\n- Resolves modules from relative paths, `VIBE_PATH`, working-directory `std/` modules, direct URLs, and `github.com/owner/repo/path@ref` imports.\n- Runs against local or remote model servers, with first-class support for Ollama, `llama.cpp`, OpenAI, Groq, and other OpenAI-compatible gateways.\n- Sends chat-style structured JSON requests to local backends, which works better with modern Gemma 4 model servers.\n- Caches parsed prompt templates so repeated `${...}` interpolation work does not keep reparsing the same expressions.\n- Ships standard-library modules written in vibelang itself, including `std/web`, `std/react`, `std/config`, `std/telemetry`, `std/runtime`, and `std/ai`, with `std/web` able to render wasm-oriented HTML shells that expose initial state and optional host model endpoints, `std/react` able to generate React-like shells over the same host-model pattern, and `std/config` able to summarize TOML-driven configuration with AI.\n\n## Quick Start\n\nBuild the interpreter:\n\n```bash\ngo build -o bin/vibelang ./cmd/vibelang\n```\n\nRun the included example with Ollama:\n\n```bash\nollama serve\nollama pull gemma4\n./bin/vibelang --provider ollama --model gemma4 examples/hello.vibe\n```\n\nFor smaller local runs, Ollama also exposes lighter Gemma 4 tags such as `gemma4:e4b`.\n\nRun the same program with `llama.cpp`:\n\n```bash\nllama-server -m /models/gemma4.gguf --port 8080\n./bin/vibelang --provider llamacpp --endpoint http://127.0.0.1:8080 --model gemma4 examples/hello.vibe\n```\n\nIf your local model tag or GGUF filename uses a different name, pass that exact value with `--model`.\n\nRun against a remote OpenAI-compatible endpoint:\n\n```bash\nexport OPENAI_API_KEY=...\n./bin/vibelang --provider openai --model gpt-4.1-mini examples/hello.vibe\n```\n\n```bash\nexport GROQ_API_KEY=...\n./bin/vibelang --provider groq --model openai/gpt-oss-20b examples/hello.vibe\n```\n\nValidate a program without hitting the model:\n\n```bash\n./bin/vibelang --check examples/modules/main.vibe\n```\n\nPrint the interpreter version:\n\n```bash\n./bin/vibelang --version\n```\n\n## Example\n\n```python\ndef summarize_weather(city: string, tone: string = \"crisp\") -\u003e string:\n    Write one ${tone} sentence about the weather in ${city}.\n\ncity = \"Berlin\"\nforecast = summarize_weather(city=city)\nprint(forecast)\n```\n\nInline prompts work anywhere a full expression makes sense in statement position:\n\n```python\nworkspace = join_path([cwd(), \"tmp\"])\nmake_dir(workspace)\npath = join_path([workspace, \"pi.txt\"])\ndigits = * return the first 5 digits of pi as a string without explanation.\n\nif * check whether ${path} already exists:\n    * delete the file at ${path}.\nelse:\n    * write ${digits} to the file at ${path}.\n```\n\nPrompt interpolation is expression-aware, not just name-aware:\n\n```python\ndef explain_file(path: string, digits: string, tone: string = \"matter-of-fact\") -\u003e string:\n    Write one ${tone} sentence about ${basename(path)} inside ${dirname(path)}.\n    Mention that ${digits} has ${len(digits)} characters.\n```\n\nAI bodies can also declare execution controls up front:\n\n```python\ndef slugify(title: string) -\u003e string:\n    @temperature 0\n    @max_steps 4\n    @cache true\n    @system You are a literal slugging assistant. Return only the slug text.\n    @tools lower, trim, replace, regex_replace\n    Convert ${title} into a lowercase URL slug.\n    Replace whitespace runs with \"-\".\n    Remove punctuation and collapse repeated \"-\" runs.\n```\n\nBodies can also pin themselves to a different model route when one program needs both local and remote execution:\n\n```python\ndef summarize_release(changes: list[string]) -\u003e string:\n    @provider openai-compatible\n    @endpoint https://models.example.com/v1\n    @model hosted-gemma\n    @api_key_env VIBE_REMOTE_API_KEY\n    @timeout_ms 10000\n    Summarize ${json_pretty(changes)} in one crisp paragraph.\n```\n\nSlices are first-class expressions:\n\n```python\ndigits = \"31415926535\"\nitems = [\"alpha\", \"beta\", \"gamma\", \"delta\"]\n\nprint(digits[:5])\nprint(digits[-3:])\nprint(items[1:3])\nprint(items[::-1])\n```\n\nComprehensions work the way Python users expect:\n\n```python\nnames = [upper(name) for name in [\"ada\", \"grace\", \"linus\"] if \"a\" in name]\nlengths = {name: len(name) for name in names if len(name) \u003e 3}\n\nprint(json(names))\nprint(json(lengths))\n```\n\nPython-shaped collection helpers keep deterministic reshaping out of the model loop:\n\n```python\nvalues = [1, 2, 3, 4, 5]\ngroups = batched(values, 2)\n\nprint(all([true, 1, \"Ada\"]))\nprint(any([false, \"\", \"vibe\"]))\nprint(json(reversed(values)))\nprint(json(flatten(groups)))\nprint(json(dict_delete({\"name\": \"Ada\", \"role\": \"builder\"}, \"role\")))\nprint(json(set_values(set_symmetric_difference(set([1, 2, 3]), set([3, 4])))))\n```\n\nUnpacking works in plain assignments and loop headers:\n\n```python\nfirst, second = [\"Ada\", \"Lovelace\"]\nprint(first)\nprint(second)\n\nfor index, label in zip([1, 2, 3], [\"a\", \"b\", \"c\"]):\n    print(index)\n    print(label)\n```\n\nAssertions make deterministic invariants explicit:\n\n```python\nsnapshot = runtime_metrics()\nassert snapshot[\"go.goroutine.count\"] \u003e= 1, \"expected at least one goroutine\"\n```\n\nPattern matching lets deterministic code branch on data shape before handing the rest to AI:\n\n```python\npacket = {\"type\": \"message\", \"payload\": [\"alpha\", \"beta\"], \"meta\": {\"city\": \"Berlin\"}}\n\nmatch packet:\n    case {\"type\": \"ping\"}:\n        print(\"pong\")\n    case {\"type\": \"message\", \"payload\": [head, tail]} if head == tail:\n        print(\"duplicate payload\")\n    case {\"type\": \"message\", \"payload\": [head, tail], \"meta\": {\"city\": city}}:\n        print(head)\n        print(tail)\n        print(city)\n    case _:\n        print(\"fallback\")\n```\n\nAI macros expand into real expressions before evaluation:\n\n```python\nmacro even_numbers(limit: int) -\u003e list[int]:\n    Return one valid vibelang expression that builds the even numbers below ${limit} * 2.\n    Prefer using range with explicit named arguments.\n\nnumbers = @even_numbers(5)\nprint(numbers)\n```\n\nStructured outputs can stay Python-shaped while still giving the model a precise target:\n\n```python\ndef describe_weather(city: string) -\u003e dict{city: string, summary: string, alerts: optional[list[string]], stats: dict{temp_c: int, wind_kph: int}, focus: tuple[string, int]}:\n    Return a compact weather object for ${city}.\n\nprint(json_pretty(describe_weather(\"Berlin\")))\n```\n\nModules are ordinary `.vibe` files:\n\n```python\n# shared.vibe\nprefix = \"Dr.\"\n\ndef format_name(name: string) -\u003e string:\n    Return exactly: ${prefix} ${name}\n```\n\n```python\n# main.vibe\nfrom \"./shared.vibe\" import prefix, format_name\nimport \"./shared.vibe\" as shared\n\nprint(prefix)\nprint(format_name(\"Ada\"))\nprint(shared.format_name(\"Grace\"))\n```\n\nConcurrent work uses native Go-backed primitives:\n\n```python\nch = channel(1)\nchannel_send(ch, \"tasks queued\")\n\nwg = wait_group()\nwait_group_add(wg, 2)\n\nfirst = spawn(str, args=[42], wait_group=wg)\nsecond = spawn(join, args=[[\"vibe\", \"lang\"], \"-\"], wait_group=wg)\n\nnotice = channel_recv(ch)\nwait_group_wait(wg)\n\nprint(notice[\"value\"])\nprint(await_task(first))\nprint(await_task(second))\n```\n\nChannel selection adds a more Go-like coordination primitive:\n\n```python\nfast = channel(1)\nslow = channel(1)\nchannel_send(slow, \"background\")\n\npacket = channel_select([fast, slow], timeout_ms=10)\nprint(packet[\"channel\"] == slow)\nprint(packet[\"value\"])\n```\n\nPrograms can inspect the helper surface deterministically:\n\n```python\njson_tools = tool_catalog(prefix=\"json_\")\nprint(json_tools[0][\"name\"])\nprint(tool_describe(\"http_request\")[\"params\"][0][\"name\"])\n```\n\nExplicit AI caching is useful for expensive deterministic helpers:\n\n```python\ndef normalize_city(city: string) -\u003e string:\n    @temperature 0\n    @cache true\n    Return ${city} in uppercase letters.\n\nprint(normalize_city(\"berlin\"))\nprint(normalize_city(\"berlin\"))\nprint(cache_stats()[\"entries\"])\n```\n\nHTTP handlers can also be AI-backed:\n\n```python\nimport \"std/web\" as web\n\ndef handle(request: dict) -\u003e dict:\n    Call web.render_app_shell with the title \"vibelang demo\", the route ${request[\"path\"]}, and initial state {\"path\": request[\"path\"]}.\n    Return a dict with html set to that app shell.\n\nserver = http_serve(\"127.0.0.1:0\", handle)\nresponse = http_request(\"http://\" + server[\"address\"] + \"/hello\")\nprint(response[\"status\"])\nhttp_server_stop(server[\"handle\"])\n```\n\nStatic frontend bundles can stay deterministic and still plug into the same HTTP surface:\n\n```python\nsite = join_path([cwd(), \"site\"])\nmake_dir(join_path([site, \"pkg\"]))\nwrite_file(join_path([site, \"index.html\"]), \"\u003ch1\u003evibelang\u003c/h1\u003e\")\nwrite_file(join_path([site, \"pkg\", \"app.wasm\"]), \"\\u0000asm\")\n\nhome = http_static_response(site, {\"path\": \"/\"}, cache_control=\"public, max-age=60\")\nwasm = http_static_response(site, {\"path\": \"/pkg/app.wasm\"})\n\nprint(home[\"headers\"][\"Content-Type\"])\nprint(wasm[\"headers\"][\"Content-Type\"])\n```\n\n`std/web` can also render wasm-first shells for AI-backed routes:\n\n```python\nimport \"std/web\" as web\n\ndef handle(request: dict) -\u003e dict:\n    Call web.respond_wasm_shell with the title \"vibelang wasm demo\", the route ${request[\"path\"]}, state {\"path\": request[\"path\"]}, brief \"A dashboard shell that boots a wasm bundle.\", wasm_path \"/pkg/app.wasm\", js_path \"/pkg/app.js\", and model_endpoint \"/api/llm\".\n```\n\n`std/react` adds a React-like route-shell prompt module for AI-authored frontend scaffolding:\n\n```python\nimport \"std/react\" as react\n\ndef handle(request: dict) -\u003e dict:\n    Call react.respond_react_shell with the title \"vibelang react shell\", route ${request[\"path\"]}, state {\"path\": request[\"path\"], \"user\": {\"name\": \"Ada\"}}, brief \"A React-like dashboard shell with one interactive root.\", model_endpoint \"/api/llm\".\n```\n\nSSE handlers can stream channel-backed event feeds:\n\n```python\nupdates = channel(2)\nchannel_send(updates, sse_event(\"booting\", event=\"status\", id=\"evt-1\"))\nchannel_send(updates, \"done\")\nchannel_close(updates)\n\ndef handle(request: dict) -\u003e dict:\n    Return exactly {\"status\": 200, \"sse_channel\": updates}.\n\nserver = http_serve(\"127.0.0.1:0\", handle)\nresponse = http_request(\"http://\" + server[\"address\"] + \"/events\")\nprint(response[\"headers\"][\"Content-Type\"])\nhttp_server_stop(server[\"handle\"])\n```\n\nHTTP handlers can also upgrade into AI-backed WebSocket sessions:\n\n```python\ndef upgrade(request: dict) -\u003e dict:\n    Return exactly {\"websocket\": \"chat\"}.\n\ndef chat(session: dict) -\u003e none:\n    Receive one websocket message from session[\"handle\"].\n    Reply with the uppercased text.\n    Close the websocket.\n\nserver = http_serve(\"127.0.0.1:0\", upgrade)\nclient = websocket_dial(\"ws://\" + server[\"address\"] + \"/chat\")\nwebsocket_send(client, \"ping\")\npacket = websocket_recv(client, timeout_ms=1000)\nprint(packet[\"data\"])\nwebsocket_close(client)\nhttp_server_stop(server[\"handle\"])\n```\n\nOrdered route tables keep larger AI-backed services predictable:\n\n```python\ndef home(request: dict) -\u003e dict:\n    Return a dict with status 200, json {\"route\": \"home\"}.\n\ndef profile(request: dict) -\u003e dict:\n    Return a dict with status 200, json {\"route\": \"profile\", \"id\": request[\"params\"][\"id\"]}.\n\nroutes = [{\"pattern\": \"/\", \"handler\": home}, {\"pattern\": \"/users/:id\", \"methods\": [\"GET\"], \"handler\": profile}]\nserver = http_serve_routes(\"127.0.0.1:0\", routes)\n```\n\nTCP listener handles let deterministic code accept sockets while AI stays focused on the protocol logic:\n\n```python\nlistener = socket_listen(\"127.0.0.1:0\")\naccept_task = spawn(socket_accept, args=[listener[\"handle\"]])\nclient = socket_open(listener[\"address\"])\naccepted = await_task(accept_task)\n\nsocket_write(client, \"ping\")\nprint(socket_read(accepted[\"handle\"]))\nsocket_listener_close(listener[\"handle\"])\n```\n\nDeterministic code can recover from runtime errors without dropping back to the host shell:\n\n```python\ntry:\n    fail(\"simulated failure\")\nexcept err:\n    print(err)\nfinally:\n    print(\"cleanup complete\")\n```\n\nBlock-scoped cleanup is available without wrapping everything in `try` / `finally`:\n\n```python\nfor name in [\"alpha\", \"beta\"]:\n    path = join_path([cwd(), name + \".tmp\"])\n    defer delete_file(path)\n    write_file(path, name)\n    print(\"created \" + basename(path))\n```\n\nURL helpers and JSON-first HTTP helpers keep API plumbing deterministic:\n\n```python\nparsed = url_parse(\"https://ada.example:8443/products/view?tag=lang\u0026tag=ai\u0026sort=desc#hero\")\nrebuilt = url_build({\"scheme\": parsed[\"scheme\"], \"host\": parsed[\"host\"], \"path\": parsed[\"path\"], \"query\": parsed[\"query\"], \"fragment\": parsed[\"fragment\"]})\nresponse = http_request_json(\"https://example.com/api\", method=\"POST\", body={\"name\": \"Ada\"})\n\nprint(parsed[\"hostname\"])\nprint(rebuilt)\nprint(response[\"json\"])\n```\n\nStructured data helpers also cover CSV, durations, and timestamp math:\n\n```python\nrows = csv_parse(\"name,role\\nAda,builder\\nGrace,scientist\\n\")\nprint(rows[1][\"role\"])\nprint(time_format(\"2026-04-17T12:34:56Z\", layout=\"date\"))\nprint(time_add(\"2026-04-17T12:34:56Z\", \"90m\"))\nprint(duration_parse(\"1h30m\"))\nprint(uuid_v7())\n```\n\nRoute matching is built in for AI-backed HTTP handlers and plain deterministic code:\n\n```python\nuser = route_match(\"/users/:id\", \"/users/42\")\nassets = route_match(\"/assets/*path\", \"/assets/css/app.css\")\n\nprint(user[\"params\"][\"id\"])\nprint(assets[\"params\"][\"path\"])\n```\n\nTOML and Markdown helpers make config-heavy web flows less prompt-dependent:\n\n```python\nconfig = toml_parse(\"title = \\\"vibelang\\\"\\n[server]\\nport = 8080\\n\")\nroute = route_build(\"/users/:id/files/*path\", {\"id\": \"42\", \"path\": \"docs/readme.md\"}, {\"tab\": \"preview\"})\nhtml = markdown_to_html(\"# Release Notes\\n\\n- shipped\\n\")\n\nprint(config[\"server\"][\"port\"])\nprint(route)\nprint(contains(html, \"\u003cli\u003eshipped\u003c/li\u003e\"))\n```\n\n## Project Layout\n\n- `cmd/vibelang`: CLI entrypoint.\n- `internal/lexer`: indentation-aware line lexer and tokenizer.\n- `internal/parser`: AST builder for statements, expressions, and raw AI function bodies.\n- `internal/runtime`: evaluator, builtins, type coercion, prompt construction, and AI tool-call loop.\n- `internal/model`: Ollama, `llama.cpp`, and OpenAI-compatible HTTP clients plus native tool-call transport.\n- `std`: bundled vibelang modules that ship prompt-native library helpers.\n- `examples`: runnable sample programs.\n- `docs`: tutorial, how-to, reference, and explanation documents.\n\n## Expanded Standard Library\n\nThe deterministic runtime now covers more of the boring work that AI functions should not hallucinate:\n\n- Filesystem: `read_file`, `write_file`, `append_file`, `copy_file`, `move_file`, `glob`, `read_json`, `write_json`, `read_yaml`, `write_yaml`, `read_toml`, `write_toml`\n- Data: `json_parse`, `json_pretty`, `yaml_parse`, `yaml_stringify`, `toml_parse`, `toml_stringify`, `csv_parse`, `csv_stringify`, `set`, `set_add`, `set_remove`, `set_has`, `set_values`, `set_union`, `set_intersection`, `set_difference`, `set_symmetric_difference`, `dict_has`, `dict_get`, `dict_set`, `dict_merge`, `dict_delete`, `all`, `any`, `reversed`, `flatten`, `batched`, `sorted`, `unique`, `sum`, `min`, `max`\n- Paths and strings: `join_path`, `abs_path`, `dirname`, `basename`, `split`, `join`, `replace`, `contains`, `base64_encode`, `base64_decode`, `url_encode`, `url_decode`, `query_encode`, `query_decode`, `url_parse`, `url_build`, `html_escape`, `markdown_to_html`, `template_render`, `sha256`, `regex_match`, `regex_find_all`, `regex_replace`, `cookie_parse`, `cookie_build`\n- System: `run_process`, `env`, `cwd`, `now`, `unix_time`, `time_parse`, `time_format`, `time_add`, `time_diff`, `duration_parse`, `uuid_v4`, `uuid_v7`, `sleep`\n- Math: `sqrt`, `pow`, `abs`, `floor`, `ceil`, plus `pi` and `e`\n- Network: `http_request`, `http_request_json`, `websocket_dial`, `websocket_send`, `websocket_recv`, `websocket_close`, `sse_event`, `socket_listen`, `socket_accept`, `socket_open`, `socket_write`, `socket_read`, `socket_local_addr`, `socket_remote_addr`, `socket_listener_close`, `socket_close`\n- Concurrency: `spawn`, `await_task`, `task_status`, `channel`, `channel_send`, `channel_recv`, `channel_select`, `channel_close`, `mutex`, `mutex_lock`, `mutex_unlock`, `wait_group`, `wait_group_add`, `wait_group_done`, `wait_group_wait`\n- Services: `route_match`, `route_build`, `mime_type`, `http_static_response`, `http_serve`, `http_serve_routes`, `http_server_stop`, plus HTTP response-mode WebSocket upgrades through `{\"websocket\": ...}`\n- Runtime introspection: `tool_catalog`, `tool_describe`\n- Observability: `log`, `otel_init_stdout`, `otel_span_start`, `otel_span_event`, `otel_span_end`, `otel_flush`, `metrics_snapshot`, `runtime_metrics`, `runtime_metric`\n\nBundled `std` modules currently include:\n\n- `std/web`: AI helpers for HTML page rendering, component fragments, app shells, wasm shells, typed HTML responses, JSON response construction, and SSE wrappers via `respond_app_shell`, `respond_wasm_shell`, `respond_json`, `respond_sse`, and `respond_sse_channel`\n- `std/react`: AI helpers for React-like component fragments and route shells via `render_react_component`, `render_react_shell`, and `respond_react_shell`\n- `std/config`: AI helpers for summarizing config objects and TOML text or files\n- `std/telemetry`: AI helpers for summarizing runtime metrics\n- `std/runtime`: AI helpers for summarizing live Go runtime metrics\n- `std/ai`: reusable AI helpers for rewriting, payload summaries, and release note drafting\n\n## Documentation\n\n- [Tutorial](docs/tutorial.md)\n- [How-to Guide](docs/how-to-run-local-models.md)\n- [Reference](docs/reference.md)\n- [Execution Model](docs/execution-model.md)\n- [Explanation](docs/explanation.md)\n\n## Status\n\nThe interpreter is production-shaped, but the runtime behavior still depends on how well the selected local model follows the JSON protocol. Lower temperatures and smaller helper-call limits generally make execution more predictable. `run_process`, network access, and file-mutating helpers are intentionally powerful, so treat `.vibe` programs the way you would treat any other local code execution surface.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Falexprogrammerde%2Fvibelang","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Falexprogrammerde%2Fvibelang","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Falexprogrammerde%2Fvibelang/lists"}