#FreePalestine. Read our founder's statement

logo

Just code

no cruft: no build systems, no null, no exception handling, no ORMs, no OOP, no inheritence hierarchies, no async/await, no compilation, no dev environments, no dependency hell, no packaging, no git, no github, no devops: no yaml, no config files, no docker, no containers, no kubernetes, no ci/cd pipelines, no terraform, no orchestrating, no infrastructure: no sql, no nosql, no connection poolers, no sharding, no indexes, no servers, no serverless, no networking, no load balancers, no 200 cloud services, no kafka, no memcached, no unix, no OSes

Send me project updates

Powered by EmailOctopus

Darklang puts everything in one box, so you can build CLIs and cloud apps with no bullshit, just code.


️️️Also it's a really enjoyable language to use!

Looking for Darklang-classic?

dark-classic
In development - here’s how things will look shortly 
              $ curl https://darklang.com/download | bash 
              
              Darklang installed in ~/.darklang/bin/darklang
              
              Add to PATH via .bashrc [y, n, ?]: y 
              ✔Added to .bashrc. 

              Next you can: 
    
      # Try the tutorial
    
   darklang tutorial 
    
      # Run some code from the package manager
    
   darklang @paul.fizzbuzz 3 
    
      # Generate some code
    
   darklang prompt "Find ts scripts with more than 600 lines which use the commonjs format"
    
      # See available command line options
    
  darklang help
              
            
                
                $ darklang @paul.fizzbuzz 3 
                1
                2 
                Fizz
                
              
                
                $ darklang deploy @paul.fizzbuzz /fizzbuzz 
                Deployed to https://furry-squirrel-3562.darklang.io/fizzbuzz in 0.135s
                 
              
                
                $ curl -sSO https://furry-squirrel-3562.darklang.io/fizzbuzz/3 
                1 
                2 
                Fizz
                
              
                $ darklang prompt "Find ts scripts with more than 600 lines which use commonjs format" 

                We need your AI credentials, which will be stored locally in ~/darklang/secrets/

                [1] Login to use Darklang AI service 
                [2] Enter GitHub copilot credentials 
                [3] Enter OpenAI (GPT 3.5/4) credentials 
                [4] Use local model 

                Enter [1-4]: 1 

                Login or register [L, r]? L
                Username: paul
                Password: **************

                ✔Logged in.

                Saved script in ./find-large-ts-cjs.dark in 43.8s
dark-file-logo

find-large-ts-cjs.dark


    let findLargeTypescriptCommonJSFiles (path : String) =
  Directory.traverse (fun path -> 
    if not (List.oneOf (File.extension path) [".ts", ".mjs", ".cjs"]) then 
      print $"Skipping - wrong file type: {path}" 
    else 
      let contents = File.readString path 
      let lines = String.splitNewlines contents
      if (List.length lines) <= 600 then 
        print $"Skipping - too short: {path}" 
      else 
        let isCommonjs = 
          lines |> List.any (fun line ->
            line |> Regex.matches "/const .* = require(.*)/" 
          ) 
        if isCommonjs then 
          print $"Found one: {path}" 
    )
    
findLargeTypescriptCommonJSFiles "./"

Functional language

Simple types using Records and Enums

Dynamic languages are great, allowing great flexibility. But now that they've matured and projects have gotten larger, static typing has been layered on top of very dynamic languages, and the intersection is not pleasant. Functional static languages like Darklang have simple Record and Enum types that can model nearly everything with much less complexity.

See example

Option and Result types instead of null and exceptions

I think it's widely accepted that nullis a mistake, and that an Optiontype (aka Optional, Maybe, etc) makes it significantly easier to program.

See example

Garbage Collected

It can be fun to satisfy the borrow checker, or manage allocations individually, but it can also be fun to just get working programs immediately. We believe that run-time garbage collection is one of the greatest programming language features, and we're all in

See example

Unicode First

Languages created last millennium typically use Strings made of bytes, or worse, UTF16 characters, or even worse, Unicode Codepoints! Like Swift, we believe that Characters should represent screen readable characters, like 👨‍👩‍👦‍👦. All characters in Darklang represent Extended Grapheme Clusters: one character that you see on screen. Naturally, working on Unicode Codepoints

2025
and normal bytes is also well supported.

See example

Runs Instantly

Instantly run any package from the CLI: darklang @username.functionName arg1 arg2

Darklang has a new model of sharing programs. Any function in the package manager can be called directly from the command line (so long as we can figure out how to coerce the command line arguments correctly)

See example

Instantly run programs as you write them

Darklang is designed for a really fast iterative loop

See example

Next-gen package management

Darklang has a rather unique package manager, where functions and types are individually versioned and immutable, taking a lot of the hassle out of package management.

  • -

     Only download the specific package items you use

  • -

     Only upgrade the specific package items you use

  • -

     Automated dependency upgrades, as we track deprecation status, and know what functions are pure and safe to update.

  • -

     Different packages can rely on different versions of other packages

  • -

     Use multiple versions of the same package item at once: allows testing new versions without having to change an entire package version, lowering risk.

  • -

     Share pre-release functions trivially, without contributors needing to check out your git repo or set up anything

  • -

     The package manager functions as a source repository

  • -

     no need for uploads, releases or other synchronization. No git or GitHub required (but you can sync to GitHub if you prefer).
Read More

Gradual Static Typing

Gradual Static Typing allows running incomplete programs so you don't need to ensure everything type checks when you're getting one path working

  • -

     While prototyping, just run code until you hit a type error

  • -

     After prototyping, run the full type checker to gain confidence your whole program works
    2025

  • -

     Full type-checking hints in VSCode or in LSP editors
    2025

  • -

     ! and ? operators allow easy error handling while you prototype

  • -

     Automatic refactoring converts ! into proper error handling
    2025
Read More

Async runtime

Fully asynchronous runtime

Darklang has a fully asynchronous runtime, so making a Http call or reading a file doesn't block the runtime.

No async / await

Adding async and await keywords to every language was a mistake. It exposes the complexity of concurrency and multi-threading to languages which were originally designed for simplicity.

Concurrent and parallel execution via data-dependencies

When you make an async request, it first waits for any arguments that are async, and starts when they're done. If another function call needs to use the result, it will wait for it before starting.

Since darklang values are immutable, there won't be any race conditions from this.

Powerful escape hatches

We provide powerful escape hatches if you need async ordering that doesn't match the data dependencies of your program.

Instant cloud deployment

Optional
2025
Instant cloud deployment of code (to our cloud or yours), with instant creation of DBs, API endpoints, and worker queues, with no containers, no cold starts, no orchestration, or other devops/cloud engineering required

Designed for GenAI

  • -

     Works with GitHub Copilot

  • -

     We redesigned the dark language and tooling to enable GenAI-generated programs, including exposing language tools to GenAI tools, allowing running partial and incomplete programs safely, and ensuring access to significant context to GenAI tools

  • -
    2025
    Build short CLI programs from prompts darklang prompt "find all js files which don't have a CSS file of the same name"

  • -

     Use any LLM: darklang's fine-tuned models
    2025
    , local OSS models, commerical models via API, or using GitHub Copilot

  • -
    2025
    Build vendor SDKs from prompts and OpenAPI docs

  • -
    2025
    Build complex programs with darklang AI agents

Works with your Editor

  • -

     VSCode Extension

  • -

     LSP support for other editors

  • -

     Works with GitHub Copilot and other GenAI tools

  • -

     We mention this because Darklang classic required using our editor, and that's no longer the case.

Open source

Darklang is open source .