# Salam Programming Language
> Salam is a fast, statically typed, open source systems language you can write in English or in Persian, and compile to a native executable for Linux, macOS, Windows and the web.
Salam has one language with two spellings: every keyword, type, standard library package and error message has an English and a Persian name, and both compile to the same native program. The course below teaches the language from the first program onward, and the standard library reference lists every package with runnable examples; almost every package page also starts with short tutorials (sections whose anchor begins with guide-, for example /std/net/httpd/#guide-...). Packages that other people keep in their own git repositories are added with salam add and are explained on the package manager page (salam init, add, remove, update, deps, search, test, install); there is no salam publish, a package is published by pushing a vX.Y.Z git tag. A Persian program starts at the function تابع ریشه, an English one at func main. This file follows the llms.txt convention; the same content in full is in llms-full.txt.
## Pages
- [Install the Salam programming language on Windows, Linux and macOS](https://www.salamlang.ir/en/install/): Download and install Salam with a single command on Windows, Linux and macOS, or run it in Docker. No administrator access needed.
- [Salam Magazine](https://www.salamlang.ir/en/blog/): In-depth articles on the Salam programming language: its bilingual design, the self-hosting compiler, measured performance, honest comparisons with C, Rust, Go and Python, and where the language is heading.
- [The Salam community](https://www.salamlang.ir/en/community/): Join the Salam community: source code on GitHub, discussion in the Telegram group, on Discord, Eitaa and Bale, issue reports, and the ways you can contribute to an open source programming language.
- [Site map](https://www.salamlang.ir/en/sitemap/): Every page, lesson and standard library package of the Salam programming language website in one list, plus the editor, the AI assistant, the Telegram bot and the project links.
- [Salam package manager](https://www.salamlang.ir/en/packages/): How to use packages from GitHub with salam init and salam add, write your own package with salam.toml, publish it with a git tag and the registry, pick versions and fix the errors you may meet.
- [Learn the Salam programming language](https://www.salamlang.ir/en/learn/): A free and complete course in the Salam programming language, in 47 lessons: from your first program through structs, enums, generics, interfaces, packages and threads to building web pages, and finally the salam serve web server with several domains, PHP and deployment; every example runs, with its real output and a live preview of each page.
- [Salam Agent](https://www.salamlang.ir/en/agent/): Download Salam Agent, the desktop app that lets Salam AI work on your computer: run commands, use Docker and WSL and edit files in a folder you choose, within the access level you set for each chat.
- [The Salam standard library](https://www.salamlang.ir/en/std/): Reference for the Salam standard library: every package, function, struct and constant, with a plain explanation and a complete example that runs.
- [How fast is Salam?](https://www.salamlang.ir/en/speed/): On 39 identical programs Salam averaged 10.6 ms, against 11.7 ms for C and 11.3 ms for Rust; 9.6x faster than PHP and 56x faster than Python. The code and the raw data are linked.
- [Salam tooling](https://www.salamlang.ir/en/tools/): The Salam online editor, the VS Code plugin and ten more editors, the English and Persian code translator, the salam commands and more than 170 standard library packages.
- [Salam AI](https://www.salamlang.ir/en/ai/): Salam AI answers questions about the Salam programming language, writes and explains Salam code, and with Salam Agent works on your own computer. Free to use with a Salam account.
## Course
- [Your first program](https://www.salamlang.ir/en/learn/start/): The entry point, running a program, printing output, exit codes, input, comments and the shape of a program
- [Variables and constants](https://www.salamlang.ir/en/learn/variables/): Declaring with :=, mutable variables, scope, globals, constants and naming rules
- [Types](https://www.salamlang.ir/en/learn/types/): Whole and decimal numbers, overflow, booleans, characters, mixing types and conversion
- [Operators](https://www.salamlang.ir/en/learn/operators/): Arithmetic, division and remainder, powers, comparison, logic, the ternary, compound assignment, bitwise flags and precedence
- [Strings and text](https://www.salamlang.ir/en/learn/strings/): String literals and escapes, joining text, bytes and characters, the str package, comparing text and reading numbers from text
- [Conditions](https://www.salamlang.ir/en/learn/conditions/): if, else if and else, comparison words, and and or, early returns, comparing floats and the rules a condition follows
- [Loops](https://www.salamlang.ir/en/learn/loops/): repeat with a count, a range and a step, the until loop and its traps, loops that end with break, each over arrays, vectors, maps and strings, nested loops, break N and continue
- [match and switch](https://www.salamlang.ir/en/learn/match/): Choosing between cases with match and switch: values, strings, enums, data and guards, struct patterns, fallthrough and switch inside loops
- [Functions](https://www.salamlang.ir/en/learn/functions/): Declaring and calling functions, early return, default values, several results with tuples, recursion, overloads, reference parameters and main's exit code
- [Anonymous functions](https://www.salamlang.ir/en/learn/lambdas/): Functions as values: anonymous functions, the function type, sorting with a comparator, functions that return functions and what a lambda captures
- [defer and function modifiers](https://www.salamlang.ir/en/learn/defer/): Running cleanup at the end of a block with defer, in what order and when, plus the pure, inline, noinline, noret and deprecated modifiers
- [Arrays and slices](https://www.salamlang.ir/en/learn/arrays/): Arrays, indexing, arrays of a given size, searching and totals, two dimensional arrays, copies and slices that write through
- [Vector and HashMap](https://www.salamlang.ir/en/learn/collections/): Growable lists with Vector, key and value pairs with HashMap, sorting, and Set, Stack and Queue
- [Structs](https://www.salamlang.ir/en/learn/structs/): Related data together, methods and this, pub and private, printing, copying, static members and embedding
- [Enums](https://www.salamlang.ir/en/learn/enums/): A closed set of cases, chosen values, enums in structs, enums that carry data, generic enums, and keeping a result as a value
- [New types and operators](https://www.salamlang.ir/en/learn/custom-types/): Type aliases, distinct types with their own methods and operators, operator overloading in structs, and or types
- [Generics and interfaces](https://www.salamlang.ir/en/learn/generics/): Generic functions and containers, interfaces, impl, bounds and dyn collections
- [Packages and files](https://www.salamlang.ir/en/learn/packages/): Packages, include and import, pub and privacy, folder packages and project layout
- [What the compiler insists on](https://www.salamlang.ir/en/learn/rules/): The strict rules of Salam, the error code for each, and how to fix them
- [Values, references and memory](https://www.salamlang.ir/en/learn/memory/): Copies and sharing, copy and deep_copy, freeing memory, who frees a string, pointers and memcheck
- [Conditional compilation](https://www.salamlang.ir/en/learn/compile-time/): Code for each operating system and processor, build flags with -D, and debug-only checks, all decided while compiling
- [Working with C](https://www.salamlang.ir/en/learn/c-interop/): Calling C functions with extern, printf and other variadic functions, pointers and buffers, linking libraries, and handing Salam functions to C
- [Concurrency](https://www.salamlang.ir/en/learn/threads/): Threads with spawn and join, sharing data safely, channels and parallel loops
- [Layout language: common for web and native](https://www.salamlang.ir/en/learn/layout/): The shared Salam layout DSL for web and native apps: elements, attributes, styles, components, parameterized layouts, and simpler value syntax, plus where web and desktop differ
- [Layout on the web](https://www.salamlang.ir/en/learn/layout-web/): Building web output from the layout DSL: salam page build, HTML/CSS/JS, browser events/DOM, parameterized rendering, and serving pages
- [Layout in native apps](https://www.salamlang.ir/en/learn/layout-native/): Running the same layout DSL as a native desktop app with --ui=native and Salam's UI engine, and how it differs from web/WebView
- [Pages and text](https://www.salamlang.ir/en/learn/page-text/): The shape of a page, headings, paragraphs, line breaks and every text level element: emphasis, quotes, code, edits, dates, abbreviations and mixed direction text
- [Page structure and lists](https://www.salamlang.ir/en/learn/page-structure/): Landmarks such as header, nav, main and footer, then lists, definition lists, details, dialogs, figures and addresses, and how to build a whole blog page from them
- [Links, images and media](https://www.salamlang.ir/en/learn/page-media/): Links and anchors, images with alt text and responsive sources, image maps, audio and video with subtitles, frames, embeds, canvas, SVG and math
- [Tables](https://www.salamlang.ir/en/learn/page-tables/): Tables for data: caption, header, body and footer sections, heading cells with scope, spanning cells, column groups, and how to style and scroll a table
- [Forms](https://www.salamlang.ir/en/learn/page-forms/): Forms and every form control: labels, all the input types, validation, text areas, checkboxes, radio buttons, lists, buttons, output, progress and meters, files, and handling a submit in code
- [Head, scripts and global attributes](https://www.salamlang.ir/en/learn/page-head/): The settings of the page, the head with meta and links, styles and scripts, templates and shadow trees, the attributes every element has, ARIA, data attributes and splitting a site into files
- [Styles and the box model](https://www.salamlang.ir/en/learn/css-basics/): CSS from zero: style properties as attributes, values, units and colors, the box model, sizes, margins, display, overflow, CSS functions, global rules and reusable components
- [Fonts and text styling](https://www.salamlang.ir/en/learn/css-text/): Font families and sizes, weights, web fonts, variable fonts, alignment, decoration, spacing, wrapping, text direction, vertical text, ruby and Persian typography, with every font and text property
- [Colors, backgrounds and effects](https://www.salamlang.ir/en/learn/css-backgrounds/): Text and background colors, opacity, layered backgrounds, gradients, fitting images, filters, blend modes, masks, clip paths and text that wraps around a shape
- [Borders, outlines and shadows](https://www.salamlang.ir/en/learn/css-borders/): The border shorthand and every side, logical sides, rounded corners, border images, outlines and focus rings, box shadows, broken boxes and the new corner shapes
- [Layout: flow, flex and grid](https://www.salamlang.ir/en/learn/css-layout/): Normal flow, position and z index, float, flexbox, grid, alignment, multi-column text and right-to-left pages, with every layout property and an example for each
- [Responsive pages and states](https://www.salamlang.ir/en/learn/css-responsive/): Pages that fit every screen: fluid sizes, media and container queries, dark mode, hover, focus and generated content, pointer, scrolling and print properties
- [Transitions and animations](https://www.salamlang.ir/en/learn/css-motion/): Motion on a page: transitions, transforms and 3D, keyframe animations, motion paths, scroll driven animations, view transitions and respecting reduced motion
- [The rest of CSS](https://www.salamlang.ir/en/learn/css-more/): Lists and counters, quotation marks, table settings, scroll snapping and scroll margins, anchor positioning, SVG fill and stroke, math, reading order and the other properties not covered before
- [Mouse events](https://www.salamlang.ir/en/learn/events-mouse/): Making a page react to the mouse: handlers, click, double click, other buttons, the context menu, pointer position, drawing, enter and leave, bubbling and the wheel
- [Keyboard and forms](https://www.salamlang.ir/en/learn/events-keys-forms/): Keys, focus, typing, text selection, form submit, reset and validation, the clipboard, details, popovers and dialogs: the events of every part of a page that people type into
- [Drag, touch, scroll and window](https://www.salamlang.ir/en/learn/events-drag-touch/): Drag and drop between lists, pointer and touch events, scroll and window events, and the load, error and abort events of images
- [Media, animation and other events](https://www.salamlang.ir/en/learn/events-media-more/): Audio and video events, a custom player, animation and transition events, slot changes, captions, canvas context loss and security policy violations
- [State, the DOM and timers](https://www.salamlang.ir/en/learn/events-dom/): How the pieces of an interactive page fit: state in variables, reading and changing elements, classes and styles, creating and removing elements, timers, storage, dialogs, components with handlers and how to debug
- [Whole pages: six projects](https://www.salamlang.ir/en/learn/web-projects/): Six complete pages that bring the lessons together: a landing page, a blog post with a sidebar, a sign up form with live checks, a dashboard with a CSS bar chart, a task list that remembers, and a photo gallery with a lightbox, plus how a Salam program serves a page
- [The English and Persian glossary](https://www.salamlang.ir/en/learn/keywords/): Every Salam keyword, type, built-in function, built-in method and compile-time constant in both languages
- [Best practices](https://www.salamlang.ir/en/learn/best-practices/): Check the standard library first, then design with structs, enums, interfaces and generics, keep functions small, and split a program into files
- [The salam serve web server: from one folder to many domains](https://www.salamlang.ir/en/learn/serve/): A complete guide to salam serve: serving a folder, writing the config file, virtual hosts, several domains and subdomains, PHP through php-fpm, Python and Go, using it from Salam itself, HTTPS and deployment
## Standard library
- [core](https://www.salamlang.ir/en/std/core/): Stopping a program with a clear message, and Option for a value that may or may not be there.
- [io](https://www.salamlang.ir/en/std/io/): Reading from the keyboard, reading and writing files, and writing to standard error.
- [fmt](https://www.salamlang.ir/en/std/fmt/): Turning numbers and booleans into text, aligning text, and building a string from a template.
- [conv](https://www.salamlang.ir/en/std/conv/): Converting numbers and booleans to text and back, including Persian digits, with errors for text that is not a number.
- [text.diff](https://www.salamlang.ir/en/std/text/diff/): Comparing two texts line by line, printing the difference as a unified diff and measuring how alike they are.
- [text](https://www.salamlang.ir/en/std/text/): Converting a string to UTF-16 and back, for Windows and libraries that want that format.
- [str](https://www.salamlang.ir/en/std/str/): Everything to do with text: searching, slicing, replacing, digits, case, and building long strings.
- [unicode](https://www.salamlang.ir/en/std/unicode/): What Unicode knows about a character: category, script, writing direction, case, decomposition and composition.
- [arabic](https://www.salamlang.ir/en/std/arabic/): Normalising Arabic-script text: Arabic yeh and kaf, vowel marks, tatweel, the zero width non-joiner and digits, for search and comparison.
- [bidi](https://www.salamlang.ir/en/std/bidi/): The Unicode bidirectional algorithm: the right display order when right to left and left to right text are mixed.
- [regex](https://www.salamlang.ir/en/std/regex/): Searching and replacing with a pattern: finding a number, an email address or a date in text and pulling it apart.
- [template](https://www.salamlang.ir/en/std/template/): Filling text and HTML templates with values, with automatic escaping for safety.
- [i18n](https://www.salamlang.ir/en/std/i18n/): A multilingual program: translating messages, placing values into them and choosing singular or plural.
- [math](https://www.salamlang.ir/en/std/math/): The basic mathematics: powers and roots, logarithms, trigonometry, rounding, minimum and maximum, and the greatest common divisor.
- [rand](https://www.salamlang.ir/en/std/rand/): Random numbers, text and choices: dice, one-time codes, unique identifiers and shuffling a list.
- [stats](https://www.salamlang.ir/en/std/stats/): Descriptive statistics over a list of numbers: mean, median, variance, standard deviation and percentiles.
- [types](https://www.salamlang.ir/en/std/types/): Recognising the type of a value from its text: a whole number, a decimal, a boolean or ordinary text?
- [bigint](https://www.salamlang.ir/en/std/bigint/): Whole numbers of unlimited size: large factorials, cryptography, and any arithmetic that will not fit in 64 bits.
- [decimal](https://www.salamlang.ir/en/std/decimal/): Exact decimal numbers for money and accounting, with none of the rounding error of floating point.
- [sort](https://www.salamlang.ir/en/std/sort/): Sorting vectors with the default or your own comparison, binary search, and a dozen sorting algorithms to learn from.
- [collections](https://www.salamlang.ir/en/std/collections/): Data structures: vector and map, stack, queue, deque, set, linked list, priority queue and counter.
- [matrix](https://www.salamlang.ir/en/std/matrix/): Linear algebra: matrices, systems of equations, decompositions, eigenvalues and statistics.
- [graph](https://www.salamlang.ir/en/std/graph/): Graph theory: traversal, shortest paths, spanning trees, flow, coloring, communities and centrality.
- [os](https://www.salamlang.ir/en/std/os/): Files, directories, system commands, program arguments and environment variables.
- [os.error](https://www.salamlang.ir/en/std/os/error/): The last error from a file or process operation: its code, its message and the path that failed.
- [os.platform](https://www.salamlang.ir/en/std/os/platform/): Identifying the system the program is running on: the operating system, the processor, the core count and the memory.
- [os.dl](https://www.salamlang.ir/en/std/os/dl/): Loading shared libraries at run time, looking up their functions and calling a function pointer with up to eight integer or pointer arguments.
- [os.mmap](https://www.salamlang.ir/en/std/os/mmap/): Memory pages with read, write and execute permissions: map, change the permissions of and release them.
- [os.process](https://www.salamlang.ir/en/std/os/process/): Running other programs, talking to them through pipes, reading with a time limit, telling an exit code from a signal, and stopping them.
- [os.shell](https://www.salamlang.ir/en/std/os/shell/): Running a command and getting its exit code, its output and its errors together.
- [os.temp](https://www.salamlang.ir/en/std/os/temp/): Making a temporary file or directory under a unique name.
- [os.user](https://www.salamlang.ir/en/std/os/user/): Who is running the program, and the standard directories that belong to them.
- [fs](https://www.salamlang.ir/en/std/fs/): Reading, writing, copying and moving files, file information, times and permissions, and MD5 and SHA digests.
- [fs.dir](https://www.salamlang.ir/en/std/fs/dir/): Creating, listing, copying, moving and removing directories.
- [fs.file](https://www.salamlang.ir/en/std/fs/file/): Deprecated: every function forwards to fs. Write import fs instead of import fs.file.
- [fs.path](https://www.salamlang.ir/en/std/fs/path/): Working with file paths: joining them, separating the name and the extension, absolute and relative paths, and a safety check.
- [filepath](https://www.salamlang.ir/en/std/filepath/): Path functions that never touch the file system; the same work as the fs.path package.
- [env](https://www.salamlang.ir/en/std/env/): Environment variables: reading them with the right type, .env files, the run profile, and masking sensitive values.
- [flag](https://www.salamlang.ir/en/std/flag/): Reading command line options such as --port 8080 and -v with the right type, and generating the help text.
- [cli](https://www.salamlang.ir/en/std/cli/): Command line programs with several commands, like git commit, and asking the user questions.
- [config](https://www.salamlang.ir/en/std/config/): Reading and writing INI, env and YAML settings files with dotted keys.
- [log](https://www.salamlang.ir/en/std/log/): Recording what a program does, with levels, a prefix, structured fields, JSON output and writing to a file.
- [debug](https://www.salamlang.ir/en/std/debug/): Tools for finding a bug: assertions, a hand-kept call stack, tracing and timing.
- [runtime](https://www.salamlang.ir/en/std/runtime/): Facts about the running program: the system, the memory, the uptime and the build options.
- [testing](https://www.salamlang.ir/en/std/testing/): Writing tests for your code: equality assertions, a pass and fail count, and a summary at the end.
- [error](https://www.salamlang.ir/en/std/error/): The one Error type behind throw, try and catch: a kind, a message, where it happened, and a retry policy.
- [mem](https://www.salamlang.ir/en/std/mem/): Working with memory directly: allocating and freeing, copying, arenas and pools, and leak checking.
- [term](https://www.salamlang.ir/en/std/term/): Text colour and style, cursor movement, progress bars, reading keys and the mouse, and the terminal size.
- [cpu](https://www.salamlang.ir/en/std/cpu/): Use the processor's AES and carry-less multiply instructions, and ask what the processor offers.
- [os.pty](https://www.salamlang.ir/en/std/os/pty/): Running a program on a pseudo terminal: waiting for its prompt, typing keys, and changing the window size.
- [os.signal](https://www.salamlang.ir/en/std/os/signal/): Waiting for operating system signals: stopping cleanly on Ctrl+C or SIGTERM, noticing terminal resizes, and controlling which thread receives a signal.
- [tui](https://www.salamlang.ir/en/std/tui/): Full-screen terminal programs: widgets, layout, focus, keys, mouse and resizing, drawn into a buffer and repainted only where something changed.
- [time](https://www.salamlang.ir/en/std/time/): The current time, durations, formatting and parsing dates, the monotonic clock, timers and tickers.
- [calendar](https://www.salamlang.ir/en/std/calendar/): The Jalali, Hijri and Gregorian calendars: conversion, day arithmetic, month names and time zones.
- [thread](https://www.salamlang.ir/en/std/thread/): Holding and waiting for the threads that spawn creates.
- [sync](https://www.salamlang.ir/en/std/sync/): Mutexes, condition variables, wait groups, read-write locks, semaphores and once, for coordinating threads.
- [atomic](https://www.salamlang.ir/en/std/atomic/): A counter and a flag that several threads can change safely without taking a lock by hand.
- [chan](https://www.salamlang.ir/en/std/chan/): A channel for passing values from one thread to another, with a buffer, timeouts and closing.
- [pool](https://www.salamlang.ir/en/std/pool/): Parallel loops, a bounded worker pool, goroutine-style tasks, error groups and futures.
- [ctx](https://www.salamlang.ir/en/std/ctx/): A context for cancellation and deadlines, passed from the main piece of work down to the smaller ones.
- [cron](https://www.salamlang.ir/en/std/cron/): Cron expressions with optional seconds, interval, daily, weekly, monthly and one-time jobs, tags, limits and hooks, each job on its own thread.
- [events](https://www.salamlang.ir/en/std/events/): An in-process event emitter: dotted topics with wildcards, one-shot handlers, and an optional worker thread.
- [encoding](https://www.salamlang.ir/en/std/encoding/): Turning text and data into Base64, hexadecimal and URL encoding.
- [encoding.json](https://www.salamlang.ir/en/std/encoding/json/): Building and reading JSON: from a plain string through automatic struct conversion to streaming.
- [encoding.yaml](https://www.salamlang.ir/en/std/encoding/yaml/): Reading YAML by path, building and writing it, and converting it to JSON.
- [encoding.csv](https://www.salamlang.ir/en/std/encoding/csv/): Reading and writing CSV files, with correct quoting and conversion to a dynamic value.
- [encoding.toml](https://www.salamlang.ir/en/std/encoding/toml/): Reading and writing TOML configuration files.
- [encoding.html](https://www.salamlang.ir/en/std/encoding/html/): Turning HTML entities, named and numeric, into text, and text into safe HTML.
- [encoding.url](https://www.salamlang.ir/en/std/encoding/url/): Taking a web address apart, building and editing its parameters, and resolving relative addresses.
- [encoding.query](https://www.salamlang.ir/en/std/encoding/query/): Reading and building the query string of a web address, such as q=hello&page=2.
- [encoding.envfile](https://www.salamlang.ir/en/std/encoding/envfile/): Reading and writing .env files, with variable substitution.
- [encoding.value](https://www.salamlang.ir/en/std/encoding/value/): A dynamic value for data whose shape you do not know in advance; the shared language of every format in this group.
- [encoding.serde](https://www.salamlang.ir/en/std/encoding/serde/): Detecting the format of a piece of text and converting JSON, YAML, TOML, XML and CSV into one another.
- [encoding.msgpack](https://www.salamlang.ir/en/std/encoding/msgpack/): The compact binary MessagePack format for dynamic values.
- [encoding.binary](https://www.salamlang.ir/en/std/encoding/binary/): Writing and reading numbers as bytes, big-endian or little-endian.
- [encoding.xml](https://www.salamlang.ir/en/std/encoding/xml/): Reading, building and writing XML, with XPath, DTD validation, namespaces and a light simple interface.
- [encoding.protobuf](https://www.salamlang.ir/en/std/encoding/protobuf/): Reading .proto files, the Protocol Buffers wire encoding, and generating Salam code from them.
- [compress](https://www.salamlang.ir/en/std/compress/): Byte buffers, compression methods from RLE through DEFLATE, gzip, bzip2, zstd and checksums.
- [archive](https://www.salamlang.ir/en/std/archive/): Making, listing, checking and extracting zip, tar, tar.gz, tar.zst, gzip, zstd and RAR files, with passwords and multi-volume RAR.
- [npy](https://www.salamlang.ir/en/std/npy/): Reading and writing NumPy .npy and .npz files.
- [excel](https://www.salamlang.ir/en/std/excel/): Reading and writing Excel (xlsx), OpenDocument (ods) and CSV spreadsheets: sheets, cells, styles, formulas and dates.
- [data](https://www.salamlang.ir/en/std/data/): Reading data for machine learning: CSV tables, batching samples, MNIST and images, and synthetic data.
- [net.tcp](https://www.salamlang.ir/en/std/net/tcp/): TCP servers and clients: listening, connecting, reading and writing, TLS and a connection pool.
- [net.udp](https://www.salamlang.ir/en/std/net/udp/): Sending and receiving UDP packets, with broadcast and multicast.
- [net.dns](https://www.salamlang.ir/en/std/net/dns/): Finding the address of a name and asking for any kind of DNS record.
- [net.mime](https://www.salamlang.ir/en/std/net/mime/): The media type of a file, the Content-Type header, and multipart form bodies.
- [net.proxy](https://www.salamlang.ir/en/std/net/proxy/): Connecting through an HTTP or SOCKS5 proxy, alone or in a chain.
- [net.router](https://www.salamlang.ir/en/std/net/router/): Routing HTTP requests, with parameters, groups and static files.
- [net.email](https://www.salamlang.ir/en/std/net/email/): Sending email over SMTP and reading it over IMAP and POP3.
- [net.websocket](https://www.salamlang.ir/en/std/net/websocket/): A two way connection that stays open between browser and server, with rooms for broadcasting.
- [net.http](https://www.salamlang.ir/en/std/net/http/): HTTP servers and clients: handlers, text and JSON responses, cookies and sending requests.
- [net.http.middleware](https://www.salamlang.ir/en/std/net/http/middleware/): The usual security, cache and CORS headers, and request logging, in one call.
- [net.http.validate](https://www.salamlang.ir/en/std/net/http/validate/): Checking form input and answering with a 400.
- [net.http.session](https://www.salamlang.ir/en/std/net/http/session/): User sessions over a cookie: keeping data between requests, and a CSRF token.
- [net.http.swagger](https://www.salamlang.ir/en/std/net/http/swagger/): Writing OpenAPI documentation for an API and serving the documentation page.
- [net.http2](https://www.salamlang.ir/en/std/net/http2/): The HTTP/2 protocol from the ground up: frames, HPACK header compression and streams.
- [net.socketio](https://www.salamlang.ir/en/std/net/socketio/): A Socket.IO client: events, acknowledgements, namespaces and automatic reconnection.
- [ssh](https://www.salamlang.ir/en/std/ssh/): SSH connections, running a command on a server, and working with files over SFTP.
- [ftp](https://www.salamlang.ir/en/std/ftp/): An FTP and FTPS client: listing a directory, uploading and downloading files.
- [rpc](https://www.salamlang.ir/en/std/rpc/): JSON-RPC 2.0 and MessagePack-RPC: a server, a client and registering methods.
- [grpc](https://www.salamlang.ir/en/std/grpc/): A gRPC server and client over HTTP/2: unary and streaming calls, metadata and status codes.
- [net.httpd](https://www.salamlang.ir/en/std/net/httpd/): A web server driven by a config file: several sites on one port, locations, redirects, caching, static files and FastCGI backends such as PHP.
- [net.httpd.conf](https://www.salamlang.ir/en/std/net/httpd/conf/): The reader of the web server config: blocks, settings and values in Salam block syntax, with positions for errors.
- [net.fastcgi](https://www.salamlang.ir/en/std/net/fastcgi/): A FastCGI client: run PHP or any FastCGI program behind a Salam server.
- [net.nats](https://www.salamlang.ir/en/std/net/nats/): A NATS client: publish and subscribe, request and reply, queue groups, automatic reconnection, JetStream and a key value helper.
- [net.tunnel](https://www.salamlang.ir/en/std/net/tunnel/): The shared core for proxy and VPN style tools: streams, addresses, dialers and proxy chains, a mixed inbound, routing rules with an Iran preset, share links and v2ray style configs.
- [net.socks](https://www.salamlang.ir/en/std/net/socks/): SOCKS4, SOCKS4a and SOCKS5: a client with login, BIND and UDP associate, a server with users, access rules and a pluggable way to reach targets, and a connector for proxy chains.
- [net.httpproxy](https://www.salamlang.ir/en/std/net/httpproxy/): An HTTP and HTTPS proxy: a client with Basic login and CONNECT tunnels, a server that forwards plain requests and opens tunnels, with access rules, TLS and a connector for proxy chains.
- [net.trojan](https://www.salamlang.ir/en/std/net/trojan/): The Trojan protocol: a TLS client and server that look like an ordinary HTTPS site, a fallback website for everyone who is not a client, WebSocket mode, UDP and a connector for proxy chains.
- [net.doh](https://www.salamlang.ir/en/std/net/doh/): Encrypted DNS: a resolver over DNS over HTTPS and DNS over TLS with server failover and a TTL cache, plain UDP DNS as a fallback, presets, and a local stub server for other programs.
- [net.censor](https://www.salamlang.ir/en/std/net/censor/): Helpers for networks that interfere with traffic: protocol sniffing and TLS server name reading, ClientHello fragmentation, padding, domain rule sets with Iran lists, a probe guard and a replay cache.
- [net.shadowsocks](https://www.salamlang.ir/en/std/net/shadowsocks/): A Shadowsocks client and server: AEAD and Shadowsocks 2022 ciphers, ss:// links, simple-obfs, a UDP relay, and a stream that runs over any tunnel.Stream.
- [net.transport](https://www.salamlang.ir/en/std/net/transport/): The byte stream under the VPN protocols: TCP, TLS, WebSocket and HTTP upgrade connections with SNI, ALPN and ClientHello fragmentation, plus byte buffers and addresses.
- [net.vless](https://www.salamlang.ir/en/std/net/vless/): The VLESS proxy protocol: client and server, TCP and UDP, vless:// share links, over TCP, TLS, WebSocket or any tunnel stream.
- [net.vmess](https://www.salamlang.ir/en/std/net/vmess/): The VMess proxy protocol, AEAD form only: encrypted client and server, TCP and UDP, over TCP, TLS, WebSocket or any tunnel stream, with the cryptographic building blocks exposed.
- [net.reality](https://www.salamlang.ir/en/std/net/reality/): The REALITY security layer of Xray: a client that proves itself inside a TLS 1.3 handshake, a server that shows everyone else the real website, key and short id helpers, and link parameters.
- [net.vpn](https://www.salamlang.ir/en/std/net/vpn/): One call that registers every proxy protocol with net.tunnel, so a v2ray style JSON config runs both sides, with a ready to use runner.
- [net.utls](https://www.salamlang.ir/en/std/net/utls/): TLS ClientHello fingerprints: build the first message of a TLS 1.3 handshake in the byte layout of Chrome, Firefox or Safari, compute JA3 strings, and run a handshake from it.
- [dom](https://www.salamlang.ir/en/std/dom/): Working with a web page in the browser: elements, events, timers and JavaScript objects.
- [web.canvas](https://www.salamlang.ir/en/std/web/canvas/): Drawing shapes, text and images on a browser canvas element.
- [web.keys](https://www.salamlang.ir/en/std/web/keys/): Keyboard state for browser games.
- [webpush](https://www.salamlang.ir/en/std/webpush/): Sending notifications to browsers from a server, with VAPID keys and the standard encryption.
- [graphql](https://www.salamlang.ir/en/std/graphql/): A GraphQL server: schemas, resolvers, query execution and HTTP handling.
- [google](https://www.salamlang.ir/en/std/google/): Google service account authentication for the Google APIs.
- [telegram.bot](https://www.salamlang.ir/en/std/telegram/bot/): Building a bot with the Bot API: messages, buttons, webhooks and a polling loop.
- [node](https://www.salamlang.ir/en/std/node/): A Salam program under Node.js: modules, files, processes and JavaScript objects.
- [aws](https://www.salamlang.ir/en/std/aws/): Amazon S3, SQS and STS, and any S3 compatible service, with Signature Version 4.
- [crypto](https://www.salamlang.ir/en/std/crypto/): SHA and MD5 digests, HMAC signatures, secure random numbers and password hashing.
- [jwt](https://www.salamlang.ir/en/std/jwt/): Making and checking JWT tokens, and guarding API routes.
- [tls](https://www.salamlang.ir/en/std/tls/): Secure TLS 1.3 and 1.2 connections and public key cryptography tools, with no OpenSSL needed.
- [ssl](https://www.salamlang.ir/en/std/ssl/): A familiar OpenSSL style interface for secure connections, on top of Salam's own TLS.
- [db.sql](https://www.salamlang.ir/en/std/db/sql/): Read, check and type SQL without a database: a dialect-aware parser, a schema catalog and typed placeholders.
- [db](https://www.salamlang.ir/en/std/db/): One interface shared by the database engines, schema migrations and a connection pool.
- [db.sqlite](https://www.salamlang.ir/en/std/db/sqlite/): An SQLite database in one file or in memory.
- [db.mysql](https://www.salamlang.ir/en/std/db/mysql/): Connecting to MySQL and MariaDB.
- [db.postgres](https://www.salamlang.ir/en/std/db/postgres/): A PostgreSQL client written in Salam: connection strings and URIs, TLS, queries, transactions, pools and migrations.
- [db.redis](https://www.salamlang.ir/en/std/db/redis/): A Redis client: keys and values, hashes, lists, sets and publishing.
- [db.typesense](https://www.salamlang.ir/en/std/db/typesense/): A Typesense client: collections, documents, typo tolerant, faceted, grouped, vector and union search, synonyms, curation, API keys, analytics and clusters.
- [db.elasticsearch](https://www.salamlang.ir/en/std/db/elasticsearch/): An Elasticsearch and OpenSearch client: documents, search, aggregations, bulk, SQL and index management.
- [db.meilisearch](https://www.salamlang.ir/en/std/db/meilisearch/): A Meilisearch client: indexes, documents, full text, faceted, hybrid and federated search, settings, tasks and API keys.
- [db.opensearch](https://www.salamlang.ir/en/std/db/opensearch/): An OpenSearch client: documents, bulk, the query DSL, aggregations, scroll and point in time, index admin, SQL and PPL, k-NN vector search, ISM, security and AWS signing.
- [db.clickhouse](https://www.salamlang.ir/en/std/db/clickhouse/): A ClickHouse client over the HTTP interface: statements, typed rows, batch inserts and the shared db interface.
- [llvm](https://www.salamlang.ir/en/std/llvm/): Building, optimizing, running and linking code with LLVM.
- [llvm.triple](https://www.salamlang.ir/en/std/llvm/triple/): The data layout and target features worked out from a triple, with no LLVM needed.
- [ai.optim](https://www.salamlang.ir/en/std/ai/optim/): Neural network optimisers: SGD, Adam, RMSProp and learning rate schedules.
- [ai.onnx](https://www.salamlang.ir/en/std/ai/onnx/): Reading and running ONNX models with no outside dependency.
- [ai.gguf](https://www.salamlang.ir/en/std/ai/gguf/): Reading GGUF model files, the llama.cpp format.
- [ai.tensor](https://www.salamlang.ir/en/std/ai/tensor/): Multi dimensional arrays and numeric operations for machine learning.
- [ai.autograd](https://www.salamlang.ir/en/std/ai/autograd/): Reverse mode automatic differentiation for training models.
- [ai.nn](https://www.salamlang.ir/en/std/ai/nn/): Neural network layers: linear, convolutional, recurrent, transformer, and checkpoints.
- [ai.llm](https://www.salamlang.ir/en/std/ai/llm/): Running Llama and Qwen language models from a GGUF file.
- [image](https://www.salamlang.ir/en/std/image/): Reading, editing and saving images, and writing text on them.
- [ai.ml](https://www.salamlang.ir/en/std/ai/ml/): Classic machine learning: preprocessing, regression, classification, trees, clustering and evaluation.
- [opencv](https://www.salamlang.ir/en/std/opencv/): Computer vision with OpenCV: image processing, features, face detection, neural networks and video.
- [gui.webview](https://www.salamlang.ir/en/std/gui/webview/): A native window around HTML, and a whole desktop application layer on top of it.
- [gui.raylib](https://www.salamlang.ir/en/std/gui/raylib/): Games and graphics with raylib: windows, 2D and 3D drawing, textures, text, input and audio.
- [gui.webview.pack](https://www.salamlang.ir/en/std/gui/webview/pack/): The file format that holds an application's web files.
- [gui.webview.bundle](https://www.salamlang.ir/en/std/gui/webview/bundle/): What salam bundle runs to make installers.
- [color](https://www.salamlang.ir/en/std/color/): Colours for the Salam UI standard: every colour syntax in English and Persian, checked with clear errors, conversion between colour spaces, mixing in oklab, light and dark pairs, contrast and the CSS the web target emits.
- [gui.color](https://www.salamlang.ir/en/std/gui/color/): Colours for the Salam UI standard: every colour syntax in English and Persian, checked with clear errors, conversion between colour spaces, mixing in oklab, light and dark pairs, contrast and the CSS the web target emits.
- [gui.flow](https://www.salamlang.ir/en/std/gui/flow/): The layout engine of the Salam style standard: column, row, grid, stack and flow layouts, positioning, scrolling and right to left, with incremental relayout.
- [gui.style](https://www.salamlang.ir/en/std/gui/style/): The Salam UI style standard: every property with its English and Persian name, value syntax, validation with clear errors, defaults per element, inheritance, interpolation for transitions and the CSS the web target writes.
- [audio](https://www.salamlang.ir/en/std/audio/): Sound as a clip of samples: cutting, mixing, measuring and converting it.
- [audio.wav](https://www.salamlang.ir/en/std/audio/wav/): Reading and writing WAVE files: PCM, floating point, A-law and mu-law.
- [audio.dsp](https://www.salamlang.ir/en/std/audio/dsp/): A Fourier transform, windows, filters and resampling for sound.
- [audio.codec](https://www.salamlang.ir/en/std/audio/codec/): Open and save a sound file without naming its format.
- [audio.aiff](https://www.salamlang.ir/en/std/audio/aiff/): Reading and writing AIFF and AIFF-C files.
- [audio.au](https://www.salamlang.ir/en/std/audio/au/): Reading and writing the Sun and NeXT au format.
- [audio.flac](https://www.salamlang.ir/en/std/audio/flac/): Lossless compression: reading and writing FLAC.
- [audio.tag](https://www.salamlang.ir/en/std/audio/tag/): Reading and writing the tags on a song: title, artist, album and cover art.
- [audio.music](https://www.salamlang.ir/en/std/audio/music/): Notes, scales, chords and tunings, Persian dastgah among them.
- [audio.synth](https://www.salamlang.ir/en/std/audio/synth/): Making sound from nothing: oscillators, envelopes and voices.
- [audio.midi](https://www.salamlang.ir/en/std/audio/midi/): Reading, writing and playing standard MIDI files.
- [audio.mp3](https://www.salamlang.ir/en/std/audio/mp3/): Reading the frames, headers and VBR tags of an mp3 file.
- [metatrader](https://www.salamlang.ir/en/std/metatrader/): Read account, symbols, rates and history, and send trades through a local MetaTrader 5 bridge.
- [dependency](https://www.salamlang.ir/en/std/dependency/): Dependency injection in the spirit of google/wire: named providers, interface bindings, cleanups and a graph check for missing dependencies and cycles.
## Magazine
- [What is the Salam programming language? A tour of a modern general-purpose and systems language](https://www.salamlang.ir/en/blog/what-is-salam-programming-language/): A complete introduction to Salam: the language, the self-hosting compiler, the standard library, the tools, the measured performance and the honest limits of a young language.
- [One language, two scripts: how Salam lets you program in Persian and English with the same compiler](https://www.salamlang.ir/en/blog/one-language-two-scripts/): Salam is one language with two spellings. This article shows how a Persian file and an English file reach the same compiler, share one standard library, report errors in the reader's language and call each other's packages.
- [Beyond translated keywords: the real problems of designing a programming language for Persian and Arabic](https://www.salamlang.ir/en/blog/designing-a-language-for-persian-and-arabic/): What actually goes wrong when a programming language is written in Persian or Arabic script, from names with spaces to look-alike letters, and the concrete decisions Salam made for each problem.
- [Right-to-left programming: how Salam handles Unicode, Persian digits and bidirectional text](https://www.salamlang.ir/en/blog/right-to-left-programming-unicode/): What it takes for a compiler, a standard library and an editor to handle code written right to left: source encoding, Persian digits, separators, strings as bytes and letters, the bidi algorithm and the traps that remain.
- [Can programming in your native language change computer science education?](https://www.salamlang.ir/en/blog/programming-in-your-native-language/): English is the hidden prerequisite of most programming courses. This article looks at what removing it can achieve, what the research supports, and how a bilingual language lets a student start in Persian and finish in English.
- [From Persian code to English and back: inside the salam translate tool](https://www.salamlang.ir/en/blog/salam-translate-persian-english-code/): salam translate rewrites a Salam program from English to Persian or from Persian to English without touching your own names, comments or strings. Here is what it changes, how it decides, and what to check afterwards.
- [Designing Salam's syntax: readability, simplicity and power](https://www.salamlang.ir/en/blog/salam-syntax-design/): Why Salam code looks the way it does: the decisions behind its blocks, declarations, loops, pattern matching and names, what each one costs, and how they compare with the syntax of Python, Go, Ruby and Lua.
- [Why does the world still need new programming languages? Salam's design philosophy and goals](https://www.salamlang.ir/en/blog/why-new-programming-languages/): Every successful language of the last twenty years was built to fix a specific pain. This article looks at what drove Go, Rust, Swift, Kotlin and Zig, then at the gap Salam targets and the design decisions that follow from it.
- [From source code to executable: how the Salam compiler works, stage by stage](https://www.salamlang.ir/en/blog/how-the-salam-compiler-works/): Follow a Salam program through the compiler: tokens, syntax tree, type checking and static checks, generated C or LLVM IR or machine code, and the final link, with real output from each stage.
- [When a language builds itself: inside Salam's self-hosting compiler](https://www.salamlang.ir/en/blog/self-hosting-compiler/): The Salam compiler is written in Salam. This is the story of how it got there, how a release is bootstrapped from the previous one, what self-hosting buys a young language and what it costs.
- [Three ways to generate code: Salam's C, LLVM and native backends compared](https://www.salamlang.ir/en/blog/salam-code-generation-c-llvm-native/): Salam can turn the same checked program into C, into LLVM IR or straight into machine code. A look inside each backend, real output from all three, and a practical guide to choosing.
- [Static typing in Salam: catching bugs before the program runs](https://www.salamlang.ir/en/blog/static-typing-in-salam/): Salam checks every type before it generates any code, infers most of them for you, and goes further than types: exhaustive matches, optional values, checked errors and compile-time range checks, with the real compiler messages.
- [Native compilation without a virtual machine or garbage collector: benefits, costs and performance](https://www.salamlang.ir/en/blog/native-compilation-without-vm-or-gc/): Salam programs run as plain machine code with no virtual machine and no garbage collector. What that buys you, what it costs you, how memory is handled instead, and what the benchmarks do and do not show.
- [Memory management in Salam: stack values, heap collections, defer and the ownership checker](https://www.salamlang.ir/en/blog/memory-management-in-salam/): A practical guide to memory in Salam: what is copied, what is shared, who frees what, how defer and compiler-inserted drops help, what the ownership checker catches at compile time and how memcheck finds the rest.
- [Interpreted or compiled? salam run, salam exec and salam build explained](https://www.salamlang.ir/en/blog/salam-run-vs-salam-build/): Salam is a compiled language that also ships an interpreter and a REPL. What each of check, run, build and exec actually does, how they differ, and a simple guide to picking the right one.
- [Cross-compilation in Salam: building for Linux, macOS, Windows and ARM from one machine](https://www.salamlang.ir/en/blog/cross-compilation-salam/): The --target flag, the three code generators behind it, the sysroots and linker built into the compiler, and an honest list of which targets are run in CI and which are only built.
- [From native to WebAssembly and JavaScript: everywhere a Salam program can run](https://www.salamlang.ir/en/blog/salam-webassembly-and-javascript/): One source file, several destinations: native executables, WASI modules, browser JavaScript, web pages, edge workers, an in-browser editor, phone apps and bare metal, with the trade-offs of each.
- [Is Salam really faster than C and Rust? A careful reading of the benchmark](https://www.salamlang.ir/en/blog/is-salam-faster-than-c-and-rust/): A methodology-first walk through Salam's published benchmark: what was measured, how, what the averages hide, where Salam loses, and why the honest summary is the same range as C and Rust.
- [Salam vs C: simpler code in the same native performance range?](https://www.salamlang.ir/en/blog/salam-vs-c/): The same small programs written in C and in Salam, followed by an honest comparison of memory management, strings, safety checks, C interop, performance, tooling and maturity.
- [Salam vs Rust: performance, memory management, safety and low-level control](https://www.salamlang.ir/en/blog/salam-vs-rust/): Rust proves memory safety at compile time and Salam does not. This comparison shows what each language checks, the same programs in both, the measured speed and where each one is the better choice.
- [Salam vs Go: which is better for fast web servers and concurrent software?](https://www.salamlang.ir/en/blog/salam-vs-go/): Go's goroutines and garbage collector against Salam's threads, task pool, channels and manual memory, with the same programs in both languages and an honest reading of the HTTP benchmark.
- [Salam vs Python: native speed with a simple syntax?](https://www.salamlang.ir/en/blog/salam-vs-python/): Salam reads almost like Python but compiles to native code with static types and no garbage collector. Here are the same programs in both, the measured speed difference, and the many cases where Python still wins.
- [Salam vs TypeScript: one language for the browser and the server?](https://www.salamlang.ir/en/blog/salam-vs-typescript/): TypeScript runs everywhere JavaScript does and owns the largest ecosystem in software. Salam takes another route to one language for the whole stack: a native server, a page language and a JavaScript backend. Here is how they differ in practice.
- [Salam vs C++: architecture, performance, tooling and systems programming](https://www.salamlang.ir/en/blog/salam-vs-cpp/): C++ is the default language for performance-critical software and has forty years of libraries behind it. Salam is a young systems language with a smaller surface. This comparison puts the same code side by side and is plain about where each one wins.
- [Salam vs Zig: two young compiled languages for low-level software](https://www.salamlang.ir/en/blog/salam-vs-zig/): Zig and Salam are both pre-1.0 systems languages with no garbage collector, a defer statement and a try keyword. They make very different choices about allocators, compile-time code and how much the standard library should do.
- [Salam vs Java and C#: native code versus managed runtimes](https://www.salamlang.ir/en/blog/salam-vs-java-and-csharp/): Java and C# run on managed runtimes with a JIT compiler and a garbage collector, backed by two of the largest ecosystems in software. Salam compiles ahead of time to native code with no collector. The differences reach from startup time to how a team writes code.
- [Salam vs Python and Julia for scientific computing and numerical work](https://www.salamlang.ir/en/blog/salam-vs-python-and-julia/): Python owns scientific computing through NumPy and its ecosystem, and Julia was designed for it. Salam brings a native compiler and a pure-Salam numerics library. This is what that library can do, what the benchmark rows measure, and where each language belongs.
- [Can a new programming language compete with decades-old ones? Salam's place in the global ecosystem](https://www.salamlang.ir/en/blog/can-a-new-language-compete/): Every popular language was once new, and most new languages never become popular. This article looks at what carried Go, Rust, Kotlin and others to adoption, and measures Salam against the same forces without pretending the gap is small.
- [Web development with Salam: a built-in language that generates HTML, CSS and JavaScript](https://www.salamlang.ir/en/blog/web-development-with-salam/): Salam has a page language inside its compiler. You describe a page as a tree of elements, the compiler checks every element, attribute and CSS value, and you get HTML, CSS and JavaScript back. This article walks from a static page to components, events and pages rendered by a Salam server.
- [Interactive user interfaces in Salam: components, state and event handling in the page language](https://www.salamlang.ir/en/blog/interactive-ui-components-state-events/): A practical guide to interactivity in Salam pages: handlers written in Salam, components with their own state, lists with keys, callbacks, events that bubble, and the compile-time checks around them.
- [Full-stack development with one language: can Salam bring the frontend and the backend together?](https://www.salamlang.ir/en/blog/full-stack-development-with-salam/): Salam can write the server, the database layer, the HTML and CSS, and the browser handlers in one language and one toolchain. This is how the pieces connect, with working code, and what is still missing.
- [Building fast web servers with Salam: HTTP, routing, middleware, WebSocket and gRPC](https://www.salamlang.ir/en/blog/fast-web-servers-with-salam/): Everything Salam's standard library offers for network services, from a ten-line HTTP server to WebSocket rooms and gRPC, how the server works inside, and what the router benchmark does and does not show.
- [Database applications in Salam: typed SQL, query checking and generated code](https://www.salamlang.ir/en/blog/typed-sql-database-apps/): How Salam talks to databases: one connection interface over SQLite, MySQL and PostgreSQL, migrations at start-up, a SQL checker that reads your schema, and a generator that turns annotated queries into typed functions.
- [A tour of Salam's standard library: from networking and cryptography to databases, images and AI](https://www.salamlang.ir/en/blog/salam-standard-library-tour/): Salam ships more than 170 packages with the compiler. This tour walks through them by area, runs a few of them, and says where the library is deep, where it is thin, and what it costs to have so much in std.
- [Calling C from Salam: how the FFI opens up the existing C ecosystem](https://www.salamlang.ir/en/blog/salam-c-interop-ffi/): Salam can call any C function after a one-line declaration, pass structs by value, hand its own functions to C as callbacks, load libraries at run time and even build libraries that C programs call. A practical guide with the rules that keep it safe.
- [Concurrent programming in Salam: threads, task pools, channels and synchronization](https://www.salamlang.ir/en/blog/concurrency-in-salam/): Salam's concurrency is built on operating system threads with a bounded task pool on top. This guide covers each tool, from spawn and join to channels, select, groups and futures, with programs that run, and compares the model with Go, Rust and Java.
- [Desktop and GUI applications with Salam: from WebView apps to a native UI drawn by Salam itself](https://www.salamlang.ir/en/blog/desktop-gui-apps-with-salam/): Salam has three ways to put a window on the screen: a web interface in the system's WebView, a native UI drawn by Salam from the page language, and raylib for games. What each one does, how to package it, and where each stops.
- [From command-line tools to operating system kernels: freestanding and bare-metal programming in Salam](https://www.salamlang.ir/en/blog/freestanding-salam-bare-metal/): The same compiler that builds Salam web servers can emit a program that owns the machine: no libc, no syscalls, a tiny runtime and a kernel that boots in QEMU. Here is how it works and what you still have to write yourself.
- [Scientific computing and machine learning in Salam: tensors, matrices, autograd and neural networks](https://www.salamlang.ir/en/blog/machine-learning-with-salam/): Tensors, reverse-mode autograd, neural network layers, optimizers, scikit-learn style models, ONNX and GGUF readers: Salam's machine learning stack lives in the standard library and compiles to native code. A guided tour with programs that run, and a clear list of what it does not do.
- [The Salam developer toolchain: language server, editor plugins, debugger, formatter, REPL and test runner](https://www.salamlang.ir/en/blog/salam-developer-tools/): A language is only as pleasant as its tools. Salam puts the compiler, language server, formatter, test runner, REPL, debugger launcher and memory checker in one executable, with plugins for eleven editors. What each tool does, with real output, and what is still missing.
- [The future of programming languages in the age of AI: what makes a language ready for AI-assisted development](https://www.salamlang.ir/en/blog/programming-languages-in-the-ai-era/): Code generators are good at languages they have seen millions of times and weak at everything else. A young language cannot change its training data, but it can change what happens after the first draft. What Salam does about it, and what any language designer can learn from it.
- [Programming with AI in the Salam ecosystem: Salam AI, Salam Agent, the MCP server, the API and the Telegram bot](https://www.salamlang.ir/en/blog/salam-ai-and-salam-agent/): Salam has its own assistant, a desktop agent that works in a folder on your computer, a hosted MCP server for the AI tools you already use, an API and a Telegram bot. What each one does, how they fit together, and which limits you set.
- [Can AI write code in Persian? Generating and validating Persian Salam programs](https://www.salamlang.ir/en/blog/can-ai-write-persian-code/): Writing Persian code is a harder test for a code generator than writing English code, because there is so little of it to learn from. What goes wrong, what the Salam compiler catches in Persian, and three practical ways to get Persian programs that compile and do what you meant.
- [Running AI workloads with Salam: loading GGUF language models, running ONNX and building ML tools without Python](https://www.salamlang.ir/en/blog/ai-workloads-with-salam/): Salam's standard library can read GGUF language models, run small Llama-family models on the processor and execute ONNX graphs, all in pure Salam. Here is what works, what it costs and what it is not meant for.
- [How a new programming language builds an open source ecosystem: packages, registry, documentation and contributors in Salam](https://www.salamlang.ir/en/blog/building-an-open-source-language-ecosystem/): A language is only as useful as the code around it. This is how Salam's package manager, standard library, documentation and contributor process are built, and an honest account of how small the ecosystem still is.
- [Salam in programming education: teaching beginners, computer science and compilers with one bilingual language](https://www.salamlang.ir/en/blog/salam-in-programming-education/): Salam lets a student start in Persian, move to English keywords without switching languages, and later read a production compiler written in the same language. What exists for teachers today, and what classrooms would still need.
- [Multilingual programming and the future of native-language code: could Salam's bilingual model work for other languages?](https://www.salamlang.ir/en/blog/multilingual-programming-future/): Salam compiles English and Persian source with one front end, one standard library and one set of error codes. This article takes the design apart and asks what it would take to add a third human language, and whether that is a good idea.
- [Where Salam could fit in industry: web services, cloud infrastructure, enterprise back offices and systems software](https://www.salamlang.ir/en/blog/salam-in-industry/): Salam has the technical pieces for web services, cloud tools, back-office software and systems work. It does not yet have the stability promise, ecosystem or support model most companies need. This is a map of the fit and the gaps.
- [What makes a programming language ready for production? Salam against an enterprise adoption checklist](https://www.salamlang.ir/en/blog/what-makes-a-language-production-ready/): Production readiness is not one feature but a dozen boring guarantees. This article lists them, then scores Salam honestly on each one, with the evidence from the repository and the gaps that remain.
- [Salam in five to ten years: from an open source project to a global ecosystem, and what has to happen first](https://www.salamlang.ir/en/blog/future-of-salam/): A vision piece with its feet on the ground: where Salam stands in November 2026, what the history of Go, Rust, Python and Kotlin says about how languages grow, and the five milestones that would turn Salam into a durable ecosystem.
## Install
Install the compiler with one command; the standard library comes with it, salam version prints the version, and adding -s -- --version X.Y.Z after the final sh of the Linux and macOS command installs that release.
Latest release: v0.6.4
```
# Linux and macOS
{ curl -fsSL https://raw.githubusercontent.com/SalamLang/Salam/refs/heads/main/install.sh || wget -qO- https://raw.githubusercontent.com/SalamLang/Salam/refs/heads/main/install.sh; } | sh
# Windows
irm https://raw.githubusercontent.com/SalamLang/Salam/refs/heads/main/install.ps1 | iex
```
## For AI agents
- [Full documentation in one file](https://www.salamlang.ir/en/llms-full.txt): Every lesson and every standard library page as plain text, for loading into a model's context.
- [Salam agent skill (SKILL.md)](https://raw.githubusercontent.com/SalamLang/Salam/main/SKILL.md): The up-to-date reference for writing and porting Salam code: current syntax in English and Persian, the standard library, the compiler's strict rules and the layout language. Install it as a skill in Claude Code or any agent that reads SKILL.md files.
- [Claude Code plugin](https://github.com/SalamLang/Salam/tree/main/tools/mcp/claude-plugin): A plugin with a Salam skill and commands to check, run and look up the API of Salam code.
- [MCP server](https://github.com/SalamLang/Salam/tree/main/tools/mcp): A Model Context Protocol server written in Salam that gives a model the compiler (check, build, run, format) and the real standard library index.
## Optional
- [Source code on GitHub](https://github.com/SalamLang/Salam)
- [Releases and downloads](https://github.com/SalamLang/Salam/releases)
- [Online editor](https://editor.salamlang.ir)