SuperSnova LangStatically typed languageSuperSnova Lang (Snovalang) is a statically typed language for building services, CLIs, data tools, and native binaries.
Every compilable file declares its package, imports dependencies, and defines types or functions.
package com.example.hello
import stdlib.snovalang.Console
func main(): int {
Console.printline("Hello, SuperSnova Lang!")
return 0
}The manifest names the package, declares the main file, source roots, dependencies, and typed configuration properties.
name = "com.example.api"
version = "0.1.0"
edition = "2026"
main = "src/com/example/api/Main.snova"
source_roots = ["src"]
[dependencies]
stdlib.snovalang = ["Console", "Json", "Async"]
stdlib.snovalang.http = ["HttpCore", "HttpServer"]
[properties.com.example.api]
listen_port = 8080Use the `snova` tool to create, check, run, test, format, and build programs.
snova new <name> -t api — scaffold a project from a template (api, webapp, console, datascience).snova deps — download selected standard-library packages into `.snovalang/deps`.snova check <file> — type-check without producing a binary.snova run <file> — compile and execute with interpreted output.snova build -o <path> <file> — emit a native executable.snova test — compile and run functions annotated with `@test`.snova fmt — format `.snova` sources according to language style rules.SuperSnova Lang provides integers, decimals, booleans, strings, and `unit` for side-effect-only results.
func main(): int {
let name = "SuperSnova"
var counter = 0
counter = counter + 1
let ratio: decimal = 3.5
return counter
}Structs group named fields and may define methods with value semantics.
struct Point {
public let x: decimal
public let y: decimal
method distanceSquared(): decimal {
return x * x + y * y
}
}
func main(): int {
let p = Point(3.0, 4.0)
return 0
}Classes support constructors, private state, and instance methods.
class Counter {
private var count: int
public method increment(): unit {
count = count + 1
}
public method value(): int = count
}
func main(): int {
let counter = Counter(0)
counter.increment()
return counter.value()
}Data classes provide concise product types with generated structural behavior.
data class Point {
public let x: float
public let y: float
}
data class Rect {
public let origin: Point
public let width: float
public let height: float
method area(): float = width * height
}Enums define closed sets of variants. Use `match` for exhaustive branching.
enum Direction { North South East West }
func opposite(d: Direction): Direction {
return match d {
Direction.North => Direction.South
Direction.South => Direction.North
Direction.East => Direction.West
Direction.West => Direction.East
}
}Parametric types model reusable containers and APIs.
struct User {
name: string
age: int
}
func main(): int {
let draft = Partial<User>(name: "Ada")
return 0
}Attach new methods to an existing class without modifying its original declaration.
class Counter {
private var value: int
method increment(): int {
value += 1
return value
}
}
extension Counter {
func doubleIncrement(): int {
increment()
return increment()
}
}Top-level functions live at package scope. Methods belong to classes or structs.
func divide(a: int, b: int): Result<int, string> {
if b == 0 {
return Result.err("division by zero")
}
return Result.ok(a / b)
}Inline functions power collection transforms with precise element typing.
struct Post {
public let id: int
public let title: string
}
func main(): int {
let posts: Array<Post> = Array<Post>.new()
posts.map((post) -> post.id).forEach((id) -> Console.printline(id.toString()))
return 0
}Async work returns `Task<T>` and is driven with `await`.
import stdlib.snovalang.Async
async func slowAdd(a: int, b: int): Task<int> {
await Async.sleep(0)
return a + b
}
async func main(): Task<int> {
let handle = Async.spawn(func(): int { return 42 })
return 0
}Branch with `if` / `else`. Ternary-style selection uses `if condition { a } else { b }` expressions where supported.
func classify(score: int): string {
if score >= 90 {
return "excellent"
} else {
return "good"
}
}Iterate with `for (let item in collection) { ... }` and channel consumption with `for msg <~ channel`.
func main(): int {
let values = [1, 2, 3]
for (let value in values) {
Console.printline(value.toString())
}
return 0
}Pattern match on enums, `Result`, and other algebraic types.
func main(): int {
let r = divide(10, 2)
return match r {
Result.Ok(_) => 0
Result.Err(_) => 1
}
}Model success and failure explicitly instead of throwing unchecked exceptions.
func parsePort(text: string): Result<int, string> {
return Result.ok(8080)
}
func main(): int {
let port = parsePort("8080")
return match port {
Result.Ok(value) => value
Result.Err(_) => 0
}
}Propagate errors with `?` inside `try` blocks, or chain deferred handlers.
func withTryCatch(input: string): string {
try {
let value = parseInt(input)?
return value.toString()
} catch (err: ParseError) {
return "error"
} finally {
cleanup()
}
}Capture a try-handle and continue with `map` and `catch` chains.
func withChain(input: string): int {
return try(parseInt(input))
.map((n) -> n * 2)
.catch((err: ParseError) -> -1)
}Schedule non-blocking work with `async func` and suspend with `await` inside tasks.
Buffered and unbuffered channels move values between concurrent tasks.
import stdlib.snovalang.Channels
async func main(): Task<int> {
let unbuffered = Channels.makeChannel<string>(0)
let buffered = Channels.makeChannel<int>(16)
let closed = unbuffered.isClosed()
return 0
}Lightweight concurrent units launched with the `pulsar` keyword on the M:N scheduler.
pulsar func worker(id: int): Channel<string> {
return Channel.send("done-${id}")
}
func main(): int {
let ch = pulsar worker(1)
for msg <~ ch {
Console.printline(msg)
}
return 0
}Apply transforms concurrently across collections.
import stdlib.snovalang.Parallel
async func main(): Task<int> {
let values = [1, 2, 3]
let labels = await Parallel.concurrentMapping(values, (n) -> n.toString())
return 0
}Bind a port and register routes programmatically or through endpoint decorators.
import stdlib.snovalang.http.HttpServer
async func health(req: IncomingRequest): Task<HttpResponse<HttpBody, HttpError>> {
return ok(HttpBody.fromString("{\"status\":\"ok\"}"))
}
async func main(): Task<int> {
await HttpServer.new()
.get("/health", health)
.listenOn(8080)
return 0
}Declare HTTP handlers with `@GetRequest`, `@PostRequest`, and related decorators.
@GetRequest("/", mediaType = "application/json", headers = [])
async func home(req: IncomingRequest): Task<HttpResponse<HttpBody, HttpError>> {
return ok(HttpBody.fromString("{\"ok\":true}"))
}
async func main(): Task<int> {
await HttpServer.new().mountDecorated(unit).listenOn(8080)
return 0
}Deserialize JSON bodies into declared structs at the handler boundary.
struct CreateUserRequest {
let email: string
}
@PostRequest("/users", mediaType = "application/json", headers = [])
async func createUser(body: HttpRequestBody<CreateUserRequest>): Task<HttpResult<UserDto, ValidationProblem>> {
if body.get().email == "" {
return HttpResult<UserDto, ValidationProblem>.problem(ValidationProblem("email", "must not be empty"))
}
return HttpResult<UserDto, ValidationProblem>.success(UserDto("1", body.get().email))
}Paginated list endpoints use `@Paginated` and return `Page<T>`.
@Paginated(defaultPageSize = 20, maxPageSize = 100)
@GetRequest("/users", mediaType = "application/json", headers = [])
async func listUsers(req: IncomingRequest): Task<HttpResponse<Page<UserDto>, ValidationProblem>> {
let pageRequest = req.pageRequest()
let items = Array<UserDto>.new()
return ok(Page<UserDto>.of(items, pageRequest, 0))
}Attach cross-cutting behavior with `@HttpInterceptor` before, during, or after handler execution.
@HttpInterceptor(
beforeRun = (req: IncomingRequest) -> unit,
runWhen = (req: IncomingRequest) -> unit,
afterRun = (req: IncomingRequest) -> unit
)
struct LoggingInterceptor {}Map structs to JSON field names with `@Json` and `@JsonField`.
@Json
struct DiagnosticDto {
@JsonField("code")
public let code: string
@JsonField("message")
public let message: string
}Convert between JSON text and typed values with `Json.serialize` and `Json.deserialize<T>`.
async func handler(req: IncomingRequest): Task<HttpResponse<HttpBody, HttpBody>> {
let parsed = await req.json<CreateUserRequest>()
match parsed {
Ok(body) => return ok(HttpBody.fromString("accepted"))
Err(err) => return badRequest(HttpBody.fromString("invalid json"))
}
}React to named events with `@EventAwait` and an `EventBus`.
@Json
data class GreetingPayload {
@JsonField("message")
public let message: string
}
class Greeter {
@EventAwait("greeting")
async method onGreeting(payload: GreetingPayload): Task<unit> {
Console.printline("Received: " + payload.message)
return Task.completed(unit)
}
}
async func main(): Task<int> {
let bus = EventBus.new().mountDecorated(Greeter())
event.send("greeting", GreetingPayload("Hello events!"))
return 0
}Declare tables, columns, keys, and indexes on structs.
@Table("users", schema = "public")
@Unique(name = "uq_users_email", columns = ["email"])
struct UserRow {
@PrimaryKey(name = "pk_users", columns = ["id"])
@Column("id", sqlType = Int64, nullable = false, default = Generated)
let id: long
@Column("email", sqlType = Text, nullable = false)
let email: string
}Version database changes with `@Migration`, `@Up`, and `@Down`.
@Migration(version = 1, name = "create users")
class CreateUsers {
@Up("CREATE TABLE users (id BIGINT PRIMARY KEY, email TEXT NOT NULL)")
method up(): unit {}
@Down("DROP TABLE users")
method down(): unit {}
}Bind SQL text to result structs with `@SqlQuery` and parameter structs with `@SqlParam`.
@SqlQuery<UserRow>(
name = "find_user_by_email",
sql = "SELECT id, email FROM users WHERE email = $1",
dialect = Postgres,
)
struct FindUserByEmail {
@SqlParam("email", sqlType = Text)
let email: string
}Decorators attach compile-time metadata to types, functions, and fields.
@Documented(description, example) — hover documentation for LSP and generated docs.@compilerDecorator — marks user-defined decorator structs processed by the compiler.Provide human-readable descriptions and examples for symbols.
@Documented(
description = "Adds two integers",
example = "add(2, 3) // 5"
)
func add(a: int, b: int): int {
return a + b
}Packages follow dotted names aligned with directory layout under `src/`.
package com.example.inventory
import stdlib.snovalang.ConsoleImport a specific file stem from a package. Wildcard imports are not used.
Control symbol reach across packages with `public` and internal defaults.
package com.example.shared
public func helperAvailable(): int {
return 42
}Load manifest properties into structs with `@SnovaProperties` and `@SnovaProperty`.
@SnovaProperties(prefix = "com.example.api")
struct ApiProperties {
@SnovaProperty("listen_port")
let listenPort: int
@SnovaProperty("data_dir")
let dataDir: string
}
func main(): int {
let props = Properties<ApiProperties>()
return props.listenPort
}Foundation modules available through `snova deps`.
Console — stdout/stderr output.Args — command-line arguments.Strings`, `Collections`, `Math`, `DateTime — text and data utilities.FileSystem`, `InOut`, `Bytes`, `Crypto — I/O and binary operations.Json — JSON serialization.Errors — structured error helpers and problem details.Async`, `Channels`, `Parallel`, `Sync — concurrency primitives.Net — TCP/UDP networking.http — HTTP client and server (`HttpCore`, `HttpServer`).sql — schema codegen, migrations, and runtime query helpers.data — tabular data, DataFrames, and workbook tooling.Events — event bus infrastructure.Properties — configuration binding.Context — cancellation and deadlines.Annotate functions with `@test` and run them through `snova test`.
@test
func addsNumbers(): unit {
let sum = 2 + 2
assert(sum == 4)
}Recommended verification sequence for every change.
snova check — static validation across the project.snova test — execute `@test` functions.snova run — smoke-test runtime behavior.snova build — confirm native binary emission when shipping executables.