NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
Go modules
Go modules, #1763 by repository stars
Latest stable
v0.41.0
Last release 3 months ago
23 Aug 2026
Ships fairly regularly
a new release about every 3 weeks
Nearly every release is documented
notes for 55 of 57 stable releases
Nothing withdrawn
no release was ever pulled
3 years old
103 releases · first in 2024
Drag across the ruler to compare, or tap a release to open it.
Nothing published for this version
Compared to v0.40.0, Neva v0.41.0 establishes one canonical, zero-config format for Neva source, exposes that formatter both through the CLI and a pub
Compared to v0.40.0, Neva v0.41.0 establishes one canonical, zero-config format for Neva source, exposes that formatter both through the CLI and a public Go package, adds a portable type-description substrate for future runtime tooling, and hardens several runtime and installation paths.
neva fmt is now built into the Neva CLI. It formats valid Neva source with one fixed, syntax-only style and is available for stdin, files, and recursively scanned directories.pkg/formatter provides the same formatter to tools and integrations. It parses and renders standalone Neva source without module resolution, analysis, desugaring, or code generation.std/reflect.Type and TypeNode expose a portable finite, indexed description of a Neva type. Recursive edges are represented as indexes into the same descriptor.Turn, Match, and Select now receive independent inputs concurrently, eliminating the sequential-receive deadlock risk when senders arrive in a different order.sudo; set NEVA_INSTALL_DIR to choose an explicit destination.Use neva fmt before committing, or make it a repository gate:
neva fmt -w .
neva fmt --check .
neva fmt is deliberately opinionated and has zero configuration: each valid source file has exactly one canonical layout. It is syntax-preserving, so semantic style rules and automated refactorings remain separate tooling concerns.
The design drew on gofmt, rustfmt, Prettier, Kotlin, Swift, Zig, and Odin formatters, while settling on Neva's own canon: compact layouts where they remain readable, vertical sequences when they do not, and no ambiguous alternatives for imports, indentation, or spacing.
For example, it sorts imports into their canonical groups and normalizes indentation:
Before
import {
@:zeta
third:omega
fmt
@:alpha
third:alpha
reflect
third:zeta
@:omega
runtime
}
After
import {
fmt
reflect
runtime
third:alpha
third:omega
third:zeta
@:alpha
@:omega
@:zeta
}
It also makes a single deterministic choice when a breakable sequence crosses 80 columns:
Before
type ExtremelyLongAlias very_long_package.SomeVeryLongGeneric<first_type, second_type, third_type>
interface VeryLongInterfaceName<first_very_long_type_parameter, second_very_long_type_parameter, third_very_long_type_parameter> () ()
After
type ExtremelyLongAlias very_long_package.SomeVeryLongGeneric<
first_type,
second_type,
third_type,
>
interface VeryLongInterfaceName<
first_very_long_type_parameter,
second_very_long_type_parameter,
third_very_long_type_parameter,
>() ()
For scripting and editor integration, the command supports standard output, in-place writes, diffs, file listing, parse-error continuation, and deterministic directory traversal:
neva fmt -d path/to/file.neva
neva fmt -l .
Go-based tools can import the same public package used by the CLI:
import "github.com/nevalang/neva/pkg/formatter"
formatted, err := formatter.Format(source)
std/reflect.Type is a compact graph representation for carrying a resolved Neva type as data. Its public shape is a list of TypeNode values; the relevant node forms include scalar values and indexes to composite children:
pub type Type list<TypeNode>
pub type TypeNode union {
String
List int
Struct list<StructField>
Union list<UnionCase>
}
The root is node 0; composite relationships point to other nodes by index. For example, the Neva type list<string> is carried at runtime as:
const list_of_strings reflect.Type = [
reflect.TypeNode::List(1),
reflect.TypeNode::String,
]
This makes recursive types representable without a global registry or per-message metadata.
This release deliberately provides the descriptor substrate only: it is a foundation for future reflection-aware tooling. It does not add TypeOf, #bind_type, JSON conversion, or a global type registry.
Turn, Match, and Select preserve their existing behavior while accepting independent inputs in either sender order.sudostd/reflect type descriptorhttps://github.com/nevalang/neva/compare/v0.40.0...v0.41.0
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Nothing published for this version
Compared to v0.39.0, Neva v0.40.0 redesigns streams as an explicit tagged-union protocol, expands immutable list operations, and makes common scalar c
Compared to v0.39.0, Neva v0.40.0 redesigns streams as an explicit tagged-union protocol, expands immutable list operations, and makes common scalar collections materially faster without changing their public Neva types.
stream<T> is now the tagged union Open | Data T | Close, rather than a struct carrying an implicit index and terminal flag. Stream boundaries and payloads are explicit, and an index is created only when a program asks for one with streams.Enumerate<T>.streams.Just<T> adapts one value to a stream, while streams.Enumerate<T> adds explicit zero-based indexes when they are needed.lists.Append<T> is the renamed lists.Push<T> operation. Together with new Prepend<T> and Concat<T>, it provides immutable list updates.list<T> and dict<T> values now use native typed runtime storage where possible. Scalar-list traversal is 75–87% faster; constructing a 512-int list is 82% faster, uses 64% less memory, and makes 255 fewer allocations.neva tool <name> provides a consistent CLI entry point for an installed neva-* developer tool, including neva tool lsp.neva.yml or neva.yaml, and recommend neva upgrade.Previously, every item in a stream<T> carried control metadata even when a program only needed the value:
pub type stream<T> struct {
data T
idx int
last bool
}
Now a stream is a tagged union with exactly three possible states:
pub type stream<T> union {
Open
Data T
Close
}
Open marks the beginning of a stream, Data carries a value, and Close marks completion. Sources such as streams.Range, streams.FromList, and streams.Just emit this protocol; ordinary user code normally passes streams to standard combinators rather than handling the three cases itself.
This is Neva's return to the canonical FBP stream design: bracket information packets delimit a sequence of ordinary data packets. It follows the model described by FBP pioneer J. Paul Morrison, with whom Neva's author corresponded while developing the language. The earlier indexed structure was an intermediate design; experience showed that the explicit FBP protocol is the more idiomatic and robust model.
streams.Map, Filter, ForEach, and other combinators use Switch<stream<T>> internally: they forward Open, transform or handle Data, and forward Close. The three paths are intentionally shown only as a schematic here — the actual Map graph also has a FanIn and ordering/backpressure wiring that must not be omitted:
Open -> ... -> Open
Data -> handler -> Data
Close -> ... -> Close
The model makes the protocol visible in the type system, removes a stored index from the default representation, and keeps indexing as an opt-in operation.
streams.Just<T>pub def Just<T>(data T) (res stream<T>)
Just adapts one value to an API that expects a stream. Given 42, it emits Open, Data(42), then Close.
This matters when a higher-level API is stream-oriented but the caller has one value. For example, the PNG example creates one image.Pixel, turns it into a one-item stream with Just, and passes that stream to image.New:
new image.New
just streams.Just<image.Pixel>
---
newPixel -> just -> new
streams.Enumerate<T>pub type Enumerated<T> struct {
idx int
item T
}
pub def Enumerate<T>(data stream<T>) (res stream<Enumerated<T>>)
Use Enumerate when an index is part of the program's logic. It attaches 0, 1, 2, … to Data items instead of making every stream item retain an index by default.
std/listsThis release adds three list operations. As with the rest of Neva's value operations, each returns a new list; the input list is not mutated.
lists.Append<T> — renamed from Push<T>pub def Append<T>(lst list<T>, data T) (res list<T>)
The dataflow below appends 3 to [1, 2] and produces [1, 2, 3].
append lists.Append<int>
---
[1, 2] -> append:lst
3 -> append:data
append:res -> :res // produces [1, 2, 3]
lists.Prepend<T>pub def Prepend<T>(lst list<T>, data T) (res list<T>)
Prepending 1 to [2, 3] produces [1, 2, 3].
lists.Concat<T>pub def Concat<T>(left list<T>, right list<T>) (res list<T>)
Joining [1, 2] and [3, 4] produces [1, 2, 3, 4].
concat lists.Concat<int>
---
[1, 2] -> concat:left
[3, 4] -> concat:right
concat:res -> :res // produces [1, 2, 3, 4]
This release includes a runtime optimization for common scalar collections. On the measured hot path, scalar-list traversal is 75–87% faster; constructing a 512-int list is 82% faster and uses 64% less memory. At the language level, list<T> and dict<T> are unchanged.
Internally, homogeneous scalar values no longer have to be stored as a generic runtime-message box per element when a typed representation is available.
Conceptually, the runtime can now keep an integer list or dictionary in native typed storage:
before: []Msg{Int(1), Int(2), Int(3)}
after: []int64{1, 2, 3}
before: map[string]Msg{"answer": Int(42)}
after: map[string]int64{"answer": 42}
Heterogeneous and non-scalar values retain the existing generic representation. The runtime boxes values only at boundaries that actually require generic messages.
On an Apple M1 Pro with Go 1.26.5, the benchmarked implementation delivers:
list_at and list_slice paths: 3–4% faster with one to two fewer allocations;The detailed benchmark method and raw comparison are in PR #1127.
Run an installed language server through the Neva CLI:
neva tool lsp
neva tool is a dispatcher for installed executables named neva-<name>; it does not install or update tools itself.
neva upgrade.union { ... } types rather than the removed untagged-union syntax.streams.EnumerateDocumentation, CI, benchmark, and engineering-harness improvements in the same release window are included as maintenance work.
https://github.com/nevalang/neva/compare/v0.39.0...v0.40.0
Compared to v0.38.0, this release expands the standard library with practical OS and file-handle capabilities, improves parser error handling, and tig
Compared to v0.38.0, this release expands the standard library with practical OS and file-handle capabilities, improves parser error handling, and tightens release/version maintenance.
std/io file handles: File, Open, Create, Close, ReadAllFile, and WriteAllFile.std/io.ReadAll and std/io.WriteAll remain available as convenience APIs for whole-file reads and writes.std/os with typed environment, process, filesystem, and temp-path primitives.std/os.Args runtime list construction..codex/.std/io now supports explicit open/create/read/write/close flows for programs that need to keep file access state visible in the graph.
import { bytes, io }
def WriteExample(start any) (stop any, err error) {
create io.Create?
from_string bytes.FromString
write io.WriteAllFile?
close io.Close?
---
:start -> [
'out.txt' -> create:filename,
'hello' -> from_string:data
]
from_string:res -> write:data
create:res -> write:file
write:res -> close:file
close:res -> :stop
}
std/os now covers common environment, process, filesystem, and temporary-path operations through typed, dataflow-friendly components. Query-style components are signal-triggered so programs stay explicit about when OS data is read.
import { os }
def ListCwd(start any) (res list<os.DirEntry>, err error) {
getwd os.Getwd?
read_dir os.ReadDir?
---
:start -> getwd:sig
getwd:res -> read_dir:path
read_dir:res -> :res
}
compiler.Error.std/os runtime helpers are covered by targeted unit and e2e tests.0.39.0 across checked-in manifests, examples, docs, generated headers, and test expectations.release-neva skill now documents repo-wide version bump requirements..agent, .claude/rules, and .opencode harness roots were consolidated under .codex/.https://github.com/nevalang/neva/compare/v0.38.0...v0.39.0
Compared to v0.37.1, this release makes generic node usage stricter and more explicit, improves runtime safety around edge cases, and continues intern
Compared to v0.37.1, this release makes generic node usage stricter and more explicit, improves runtime safety around edge cases, and continues internal tooling groundwork.
any fallback removed).list_at out-of-bounds flow and ArrayInport.Select behavior.pkg/view now exposes port order and DI args for downstream visual/tooling work.any semantics and container specialization policy.This change is specifically about generic nodes at initialization/callsites.
If a node is generic, pass <T> explicitly when you instantiate it.
Before (now invalid, missing type arg):
import {
fmt
runtime
}
def Main(start any) (stop any) {
println fmt.Println
panic runtime.Panic
---
:start -> "hello" -> println:data
println:res -> :stop
println:err -> panic
}
After (valid):
import {
fmt
runtime
}
def Main(start any) (stop any) {
println fmt.Println<string>
panic runtime.Panic
---
:start -> "hello" -> println:data
println:res -> :stop
println:err -> panic
}
view tests were strengthened.0.38.0 across release-related files.https://github.com/nevalang/neva/compare/v0.37.1...v0.38.0
Nothing published for this version
Nothing published for this version
Patch release after v0.37.0 focused on trace output consistency and JSONL cleanup.
Patch release after v0.37.0 focused on trace output consistency and JSONL cleanup.
receiver <- sender, branch lines).new now propagates signal causes, so causal chains can reach :start.port.Index when it is null (kept only for array ports).Compared to v0.36.1, this release starts the final language-completion track: runtime tracing first, then visual tooling, then debugger stack.
Compared to v0.36.1, this release starts the final language-completion track: runtime tracing first, then visual tooling, then debugger stack.
pkg/view foundation primitives for upcoming visual tooling.In control-flow languages, production failures are explained by stack traces. In Neva, execution is dataflow, so failure context is a causality graph of messages. This release makes that graph observable in runtime output.
When panic happens, Neva now prints a panic cause dataflow trace to stderr.
import {
fmt
runtime
}
def Main(start any) (stop any) {
panic runtime.Panic
printf fmt.Printf
---
:start -> [
'value=$1' -> printf:tpl,
10 -> printf:args[0]
]
printf:err -> panic
printf:sig -> :stop
}
Pretty trace view (target format):
panic:data <- printf:err
├─ printf:args[0] <- __newv2__2
│ └─ __newv2__2 <- :start
└─ printf:tpl <- __newv2__1
└─ __newv2__1 <- :start
import {
fmt
runtime
strconv
}
def Main(start any) (stop any) {
panic runtime.Panic
printf fmt.Printf
left_atoi strconv.Atoi
right_atoi strconv.Atoi
---
:start -> [
'left=$0 right=$1 extra=$2' -> printf:tpl,
'10' -> left_atoi,
'20' -> right_atoi
]
[left_atoi:err, right_atoi:err, printf:err] -> panic
left_atoi:res -> printf:args[0]
right_atoi:res -> printf:args[1]
printf:sig -> :stop
}
Pretty trace view (target format):
panic:data <- __fan_in__2
└─ __fan_in__2:data[2] <- printf:err
├─ printf:tpl <- __newv2__7
│ └─ __newv2__7 <- :start
├─ printf:args[0] <- left_atoi:res
│ └─ left_atoi:data <- __newv2__8
│ └─ __newv2__8 <- :start
└─ printf:args[1] <- right_atoi:res
└─ right_atoi:data <- __newv2__9
└─ __newv2__9 <- :start
Note:
Current runtime output still exposes internal synthetic node names (for example __newv2__*) and may stop short of :start for some runtime funcs. The next tracing patch will align runtime output with the target view above.
Trace events written to file are standardized as JSONL (v=2, one event per line).
Real sample from trace.log:
{"message":{},"port":{"Path":"","Port":"start"},"event":"sent","causeIndexes":null,"v":2,"index":1}
{"message":"value=$1","port":{"Path":"__newv2__1","Port":"res"},"event":"sent","causeIndexes":null,"v":2,"index":4}
{"message":"value=$1","port":{"Path":"printf","Port":"tpl"},"event":"recv","v":2,"index":4}
{"message":10,"port":{"Path":"printf","Port":"args","Index":0},"event":"recv","v":2,"index":5}
This release also includes initial pkg/view projection primitives used by the read-only visual tooling track.
The previous "Engineered Stability" release `v0.36.0` tightened delivery quality gates.
The previous "Engineered Stability" release v0.36.0 tightened delivery quality gates.
v0.36.1 is a focused patch release that continues this maintenance track: wider runtime operator coverage, benchmark surface expansion, lint debt reduction, and CI/release automation cleanup.
golangci-lint rollout with targeted suppression cleanup via refactors.Runtime/operator work filled missing paths and removed stale suppression-heavy patterns:
nolint usage in runtime funcsA delayed-echo example synchronization bug was fixed by correcting wait-group count wiring.
This release significantly expands reproducible benchmark slices for runtime behavior:
These changes improve visibility into runtime performance trends without introducing new language syntax.
.agent layout cleanup to keep harness guidance consistentNo language-level syntax or type-system semantic changes were introduced in this patch window.
Full Changelog: https://github.com/nevalang/neva/compare/v0.36.0...v0.36.1
Release binaries were re-uploaded from main commit f9dbb8e6 to fix CLI-reported compiler version metadata (neva version now reports 0.36.1).
Nothing published for this version
Nothing published for this version
A dedicated sweep addressed reachable vulnerability findings and upgraded affected modules:
The previous "Pragmatic Power" release v0.35 focused on language and stdlib leverage.
v0.36 is about making that leverage safer and more repeatable in day-to-day work: stricter release builds, stronger quality gates, cleaner CI lanes, security/toolchain refresh, and reduced maintenance noise.
go1.26.1 (including CI).lint -> unit -> e2e) and uses shared e2e binary caching.lint, test-unit, vulncheck, quality-gate, quality-gate-ci).fieldalignment cleanup was applied.A dedicated sweep addressed reachable vulnerability findings and upgraded affected modules:
github.com/go-git/go-git/v5 v5.11.0 -> v5.16.5github.com/cloudflare/circl v1.3.7 -> v1.6.3golang.org/x/crypto v0.21.0 -> v0.45.0golang.org/x/net v0.23.0 -> v0.47.0go mod tidy was re-run to normalize the module graph after the update.
Neva now targets:
go 1.26toolchain go1.26.1CI workflows were aligned to the same version to keep local/CI behavior consistent.
Release build flags are now standardized in shared backend helpers and aligned with Make targets:
-trimpath-buildvcs=false-ldflags="-s -w"This keeps end-user binaries compact and more reproducible across release paths (install, native backend, wasm backend, and release builds).
Release operations were tightened further around lightweight repo-local guidance and post-publish automation:
release-neva skill now codifies the draft-first release flow and version-bump decision pointsThe test workflow was restructured into ordered jobs:
lintunit_testse2e_testspkg/e2e now supports shared binary caching with safe fallback behavior, reducing repetitive rebuild work during e2e runs.
The repo now exposes a clearer local/CI quality path:
make lintmake test-unitmake vulncheckmake quality-gatemake quality-gate-cigovulncheck also runs as a dedicated workflow job, and optional Go-only hooks can mirror the same checks locally before commit.
After introducing safer e2e/cache mechanics, the temporary explicit -p 2 cap for e2e/examples was removed in CI. The lane now relies on default Go package parallelism.
Documentation/comments were tightened around stdlib cache invalidation:
embed.FS constraints)nolint suppressions across the repo.govet field alignment checks.make nilaway to keep the default developer path focused on production code.No language-level breaking changes were introduced in this release window. The focus of v0.36 is delivery quality and operational stability.
Full Changelog: https://github.com/nevalang/neva/compare/v0.35.0...v0.36.0
The previous "Back to Dataflow" release `v0.34` has cleaned up the language surface and removed a lot of accidental complexity.
The previous "Back to Dataflow" release v0.34 has cleaned up the language surface and removed a lot of accidental complexity.
Current "Pragmatic Power" releasev0.35 is what comes next: making that simpler core actually pleasant and powerful in real programs. This release is more about real leverage.
bytes builtin data-type for effective IO operations. We no longer pretend that all bytes are strings.streams/dicts/strings/bytes).data/res/err/sig defaults) across many components to make APIs more predictable.maybe type is no longer special case for type-system, it's just union now.[*] (instead of =>), which is much clearer and less magical.pkg/e2e package for end-to-end testing.bytesbytes is now a first-class builtin type.
Minimal snippet (nodes + network only):
read_all io.ReadAll?
bytes_to_string strings.FromBytes
println fmt.Println<any>?
---
:start -> 'bytes_roundtrip.txt' -> read_all:filename -> bytes_to_string -> println -> :stop
A concrete stdlib API example using bytes:
#extern(write_all)
pub def WriteAll(filename string, data bytes) (res any, err error)
It makes code more consistent and easier to reason about for LLMs.
// before (now invalid)
import { fmt }
def Main(start any) (stop any) {
fmt.Println
...
}
// after
import { fmt }
def Main(start any) (stop any) {
println fmt.Println
...
}
maybe/error modeling cleanupmaybe<T> is now regular tagged-union modeling in std/builtin.
pub type maybe<T> union {
Some T
None
}
pub type error struct {
text string
child maybe<error>
}
No special type-system path is needed for optional/error chaining.
We finished the remaining language cleanup from v0.34 by removing deferred connection syntax.
Before, you could write sugar like a -> { b -> c }, where delivery from b to c was deferred by a. It worked, but
c and not sending by b, which is clear using explicit locks - what desugarer was doing under the hood)So now this is explicit wiring via builtin.Lock:
lock Lock<string>
---
a -> lock:sig
b -> lock:data
lock -> c
[*]Array bypass used to use =>. Now it is explicit port-slot wildcard syntax on both sides:
// before
in:items => out:items
// after
in:items[*] -> out:items[*]
This might seem like a opinionated change but actually it's just simplification we didn't see possible before - at AST level we used to have 2 kinds of connection, a normal one and array bypass one. Now array bypass is just a special case of normal connection where array slot index is * (which is encoded as 255 - reserved uint8 value). So all connections are "normal" now. I.e. there are just "connections". Also [*] feels more consistent with [i] (e.g. [0]) rather than using different kind of arrow =>.
A lot of stdlib APIs were normalized to follow port naming convention with (data, res, err, sig) with boundary exceptions only when domain naming adds real value. The convention itself was finalized in the docs/style_guide.md document.
This is not a flashy feature, but it helps to form idiomatic conventions for the language and its standard library. This particular change should make it a little bit easier to reason about the port names. We expect you to just follow the convention without asking yourself a lot about "how do I name this port?". Also should help LLMs with codegen predictability.
streams.FromString(data string) (res stream<string>)streams.FromDict<T>(data dict<T>) (res stream<DictEntry<T>>)dicts.FromStream<T>(data stream<DictEntry<T>>) (res dict<T>)strings.FromBytes(data bytes) (res string)This introduces idiomatic convention for data-type convertors. We have decided to continue follow "small core" philosophy and made type convertors simple components rather than language feature.
dict -> streamconst dict_value dict<string> = {
a: 'one',
b: 'two'
}
...
dict_to_stream streams.FromDict<string>
for_each_println streams.ForEach<DictEntry<string>>{fmt.Println<any>}?
wait streams.Wait
---
:start -> $dict_value -> dict_to_stream -> for_each_println -> wait -> :stop
stream -> dict (last write wins)const dict_entries list<DictEntry<string>> = [
{ key: 'dup', value: 'one' },
{ key: 'dup', value: 'forty-two' }
]
...
list_to_stream streams.FromList<DictEntry<string>>
stream_to_dict dicts.FromStream<string>
println fmt.Println<any>?
---
:start -> $dict_entries -> list_to_stream -> stream_to_dict -> println -> :stop
Builtin scalar converters now explicitly document intent (aligned with Go):
Int(float) -> int (truncate toward zero)Float(int) -> floatString(int) -> string (Unicode code point)This gives a sane, predictable baseline while keeping non-total parsing/formatting in stdlib (strconv style APIs).
Bytes(string) -> bytes and String(bytes) -> string in builtin are in progress.
go fix disciplineRepository now targets:
go 1.26toolchain go1.26.0CI now enforces go fix ./... cleanliness. If you haven't read about go fix then do it. It's awesome tool that automatically rewrites legacy Go code to its modern version respecting language and stdlib changes. Now every Neva release language is going to be better and better also because of this, among with many-many other reasons.
A lot of groundwork landed to make this split working:
pkg/ast, pkg/core, pkg/indexer, pkg/typesystem,cmd/lsp removed,nevalang/neva-lsp.This is important for velocity in neva-lsp and vscode-neva: compiler core stays focused, language tooling can evolve in its own repo.
pkg/* APIs are now usable from external Go modulesExpose public APIs for external LSP extraction means you can now import Neva AST/typesystem packages directly from another Go module.
Minimal example:
package main
import (
"fmt"
src "github.com/nevalang/neva/pkg/ast"
ts "github.com/nevalang/neva/pkg/typesystem"
)
func main() {
var _ src.Component
var _ ts.Expr
fmt.Println("neva ast/typesystem imported successfully")
}
Core editor features landed:
textDocument/definition - jump to symbol definition.textDocument/references - find all usages.textDocument/rename (+ prepare rename) - safe symbol rename.textDocument/hover - quick symbol/type info.textDocument/documentSymbol - file outline navigation.textDocument/completion - entities, ports, and imports.textDocument/semanticTokens/full - syntax-aware highlighting.references, implementations) - inline code navigation counts.This is the baseline for vscode-neva and future visual tooling over LSP transport.
main was cleaned while preparing this release baseline (staticcheck + wastedassign findings).#1030) was a small but important bug-fix: pretty spacing no longer mutates string payload contents.Core to this release window:
Full Changelog: https://github.com/nevalang/neva/compare/v0.34.0...v0.35.0
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
This release is a turning point toward the 2026 Q1 priority: a polished, “wow‑factor” working prototype. To get there we needed to correct language de
This release is a turning point toward the 2026 Q1 priority: a polished, “wow‑factor” working prototype. To get there we needed to correct language design mistakes before moving forward. v0.34 finishes that simplification effort and brings Neva back to its roots: a small core and pure dataflow. We’re no longer trying to mimic conventional programming languages — we’re doubling down on what makes Neva different.
With this foundation in place, we can finally shift focus to the visual node editor. The language syntax/semantics are now kinda stable: expect small tweaks, but no major reshaping. The next frontier is stdlib APIs and patterns rather than the language itself.
This release continues the language simplification work: composite sender syntax is removed in favor of explicit stdlib components, and const/literal senders are now strictly chain-only. Alongside the language changes, you get a new neva install command, clearer compiler diagnostics, and updated stdlib APIs.
Neva is a pure dataflow language: messages flow between nodes over connections. Composite senders (expressions, range syntax, ternary, switch syntax, union wrapping syntax) pull references from the network in sender position, which conflicts with chain-only semantics (constants/literals/union tags must be triggered). This created:
1..10 implies streams.Range and auto-imports).Switch note below).v0.34.0 removes these composite senders and requires explicit wiring. This makes the textual format a faithful serialization of the graph and restores a single, consistent rule: senders are nodes or chain-only literals/consts triggered by a signal.
The following language-level constructs are removed in v0.34.0:
-x, a + b, a && b).switch language construct.1..10).Type::Tag(data) as a sender).Use explicit stdlib components instead. This keeps the text format aligned with the visual dataflow model.
// before
x + y -> out:data
// after (builtin is implicit)
add Add
---
:x -> add:left
:y -> add:right
add -> :res
// before
cond ? a : b -> out:data
// after (builtin is implicit)
ternary Ternary<string>
---
:cond -> ternary:if
:a -> ternary:then
:b -> ternary:else
ternary -> :res
switch construct// before
value -> switch {
case1 -> handle1
case2 -> handle2
_ -> handle_default
}
// after (builtin is implicit)
switch Switch<string>
---
:value -> switch:data
:start -> [
'Alice' -> switch:case[0] -> :out1,
'Bob' -> switch:case[1] -> :out2
]
switch:else -> :out_default
// before
1..10 -> stream:data
// after
import { streams }
range streams.Range
---
:start -> [
1 -> range:from,
10 -> range:to
]
range:res -> :stop
// before
type MyUnion union { Tag int }
MyUnion::Tag(value) -> handler
// after (builtin is implicit)
type MyUnion union { Tag int }
union Union<MyUnion>
---
:data -> union:data
:start -> MyUnion::Tag -> union:tag
union -> :res
Standalone const or literal senders are no longer allowed. They must appear in a chain triggered by a signal.
// before (invalid)
$answer -> print:data
42 -> print:data
// after
:start -> [
$answer -> print:data,
42 -> print:data
]
Switch<T> and the Type placeholder (type-system note)Removing the language switch construct exposes a deeper type-system reality: union elimination is not expressible as a normal generic component. A true pattern match needs different output types per branch, but Neva’s type system assigns a single type T to Switch<T> ports. A naive Switch<T> therefore cannot statically refine types by tag.
To keep the language minimal and preserve switch-like behavior, Neva keeps Switch as a stdlib component, while the compiler applies special typing rules to its case outputs. The signature uses a placeholder type Type to indicate “compiler-determined output type” per case:
pub def Switch<T>(data T, [case] T) ([case] Type, else T)
Type is not a real runtime type. It is a documentation/typing placeholder that signals compiler participation. This is a deliberate, constrained “compiler magic” to keep the surface language small while acknowledging that union elimination is not soundly expressible as a normal generic function today (see #969 for details).
Comments are now allowed inside import { ... } blocks and as trailing comments on import lines.
import {
fmt
strings // used for joining
}
Multi-line struct literals can now end with a trailing comma.
const person Person = {
name: 'Ada',
}
neva install commandBuild and install a Neva program to your Go bin path (GOBIN, GOPATH/bin, or ~/go/bin) using the package directory name as the binary name.
neva install path/to/pkg
Real‑world examples:
# Install a CLI from a local module
neva install ./cmd/hello
# Install the main package from a module root
neva install .
# Then run it
hello
A new --debug-runtime-validation flag is available for language developers. It emits a validation helper into the generated runtime to print unconnected senders/receivers for wiring inspection, without shipping that helper in the repo runtime by default.
# Inspect runtime wiring during development
neva run --debug-runtime-validation path/to/pkg
builtin.<Name> when appropriate.std/os/dotenv loaders no longer return dictionaries. They load into the process environment and send a completion signal.
import {
os/dotenv
}
def Main(start any) (stop any) {
load dotenv.Load
---
:start -> load -> :stop
}
Load a specific file via LoadFrom, and use the override variants when needed:
import {
os/dotenv
}
def Main(start any) (stop any) {
load dotenv.LoadFrom
---
:start -> './config/.env' -> load:data -> load:res -> :stop
}
import {
os/dotenv
}
def Main(start any) (stop any) {
load dotenv.LoadFromOverride
---
:start -> './config/.env' -> load:data -> load:res -> :stop
}
Available components in std/os/dotenv:
LoadLoadFromLoadOverrideLoadFromOverrideos.EnvironRetrieve the current process environment as list<string> in KEY=VALUE form. This mirrors Go’s os.Environ() API, which returns a slice of KEY=VALUE strings rather than a map, so Neva exposes the same shape for consistency with the runtime implementation.
import {
fmt
os
}
def Main(start any) (stop any) {
environ os.Environ
println fmt.Println<list<string>>
---
:start -> environ -> println -> :stop
}
streams.Range is now explicit (breaking)The .. syntax and sig-gated Range variant are removed. Use streams.Range with explicit wiring.
import { streams }
def Main(start any) (stop any) {
range streams.Range
---
:start -> [
1 -> range:from,
10 -> range:to
]
range -> :stop
}
Union senders are removed. Use the Union<T> component.
type MyUnion union { Tag int }
def WrapUnion(start any, data int) (res MyUnion) {
union Union<MyUnion>
---
:data -> union:data
:start -> MyUnion::Tag -> union:tag
union -> :res
}
Unary/binary expressions -> builtin operators (e.g., Add, Sub, Eq)
ternary -> Ternary<T>
switch {...} -> Switch<T>
1..10 -> streams.Range (from/to wiring)
Type::Tag(data) sender -> Union<T>
Standalone literals/consts -> Chain from a signal
Dotenv Load returning dict -> signal-only loaders + os.Environ
Added or changed components in v0.34.0:
os.Environ (new)os/dotenv.Load, LoadFrom, LoadOverride, LoadFromOverride (changed to signal-style)streams.Range (moved to streams, single explicit variant)Union<T> (unchanged component; now required for union wrapping instead of union senders)golangci-lint configuration with an explicit allowlist and new quality/security linters enabled. Highlights include gosec, govet with fieldalignment, depguard, gochecknoglobals, gochecknoinits, gocritic, revive, errorlint, nilerr/nilnil, copyloopvar, and tparallel. This tightened bar took focused cleanup work and materially improves correctness, security, and maintainability..checksum file under ~/neva/std. If it matches, the existing on-disk stdlib is reused; if it differs, the stdlib is fully re-extracted and the checksum updated. This prevents stale stdlib copies after upgrades while keeping fast startup when nothing changed.Issues: #963, #969, #797
Pull requests: #951, #953, #955, #956, #958, #974, #978, #981, #991, #992, #993, #994, #995, #997, #998, #1005, #1006, #1009
Full Changelog: https://github.com/nevalang/neva/compare/v0.33.0...v0.34.0
Nothing published for this version
This release brings a major milestone: Go interop — you can now call Neva code from Go. This opens the door for gradual adoption and integration with
This release brings a major milestone: Go interop — you can now call Neva code from Go. This opens the door for gradual adoption and integration with the Go ecosystem. Along with that, we've added developer productivity features like watch mode and stdlib search, plus important improvements to streams, tracing, and the type system.
Neva can now be compiled as a Go library and called from Go code. This is the biggest change in this release.
The compiler identifies all public components with exactly one inport and one outport as interopable exports. Under the hood, it generates Go code that can be imported and used like any other Go package.
# Build Neva package as Go library
neva build --target go --target-go-mode pkg path/to/package
# Specify custom runtime path if needed
neva build --target go --target-go-mode pkg --target-go-runtime-path ./runtime path/to/package
The compiler will:
package main
import (
"fmt"
"your-module/generated"
)
func main() {
// Call Neva components from Go
result := generated.YourNevaComponent(input)
fmt.Println(result)
}
Each exported Neva component becomes a Go function. The runtime handles message passing and dataflow execution transparently.
The compiler itself uses this feature: Part of the Neva compiler is now written in Neva! For example, ParseEntityRef is implemented in Neva and called from Go
See PRs #916 and #949 for implementation details.
Experimental Three.js-powered 3D visualization of intermediete program representation (IR). Helps understand how your Neva code is transformed and executed.
# Generate 3D visualization
neva build --target ir --target-ir-format threejs main
# Open ir.threejs.html in your browser
<img width="2058" height="1336" alt="image" src="https://github.com/user-attachments/assets/dbf331fc-aa07-4890-84bd-1ab48eb81835" />
Also mermaid IR visualizer added and can be used like this
neva build --target ir --target-ir-format mermaid main
<img width="1040" height="1336" alt="image" src="https://github.com/user-attachments/assets/6f4cb89c-9088-4a03-b7b6-7eed766468f6" />
Other IR formats are also available: json, yaml and dot.
neva doc - Standard Library SearchSearch the Neva standard library using regular expressions. Quickly find components, types, and functions without leaving your terminal.
# Search entire stdlib
neva doc "ZipMany"
# Search specific package
neva doc streams "Zip"
# Search with context lines
neva doc -C 5 "LoadEnv"
Example output:
std/streams/streams.neva:32
26 | // === ZipMany ===
27 |
28 | // Produces a stream of lists where each list contains items from the
29 | // corresponding positions of the input streams. Stops when any stream is
30 | // exhausted.
31 | #extern(stream_zip_many)
> 32 | pub def ZipMany<T>([data] stream<T>) (res stream<list<T>>)
33 |
34 | // === Product ===
The command supports:
neva doc package/path pattern-C flagSee PR #927.
Automatically rebuild and rerun your Neva programs when source files change.
# Run with watch mode
neva run --watch main
# Watch mode with trace enabled
neva run --watch --emit-trace main
The watcher:
.neva files and neva.yaml/neva.yml manifestsSee PR #931.
Generated trace logs now include metadata headers with debugging information. When using --emit-trace, you'll get richer context about program execution.
# Build with trace
neva build --emit-trace main
# Run with trace
neva run --emit-trace main
See PRs #920 and #928.
checkOperatorOperandTypesWithTypeSystem for stricter compile-time checks of operator operand typesBetter error messages throughout the compiler pipeline, especially for:
See PRs #938, #941, #944.
streams.ZipMany - Zip Multiple StreamsCombine multiple streams into a single stream of lists. Perfect for processing parallel data sources.
pub def ZipMany<T>([data] stream<T>) (res stream<list<T>>)
Example:
import { streams, fmt, runtime }
const first list<int> = [1, 2, 3]
const second list<int> = [10, 20, 30]
const third list<int> = [100, 200, 300]
def Main(start any) (stop any) {
l2s1 ListToStream<int>
l2s2 ListToStream<int>
l2s3 ListToStream<int>
zip_many streams.ZipMany<int>
for For<list<int>>{fmt.Println<list<int>>}
wait streams.Wait
panic runtime.Panic
---
:start -> [
$first -> l2s1 -> zip_many:data[0],
$second -> l2s2 -> zip_many:data[1],
$third -> l2s3 -> zip_many:data[2]
]
zip_many:res -> for
for:res -> wait -> :stop
for:err -> panic
}
Output:
[1, 10, 100]
[2, 20, 200]
[3, 30, 300]
Stops when any input stream is exhausted. See PR #919.
streams.Wait RelocationThe Wait helper moved to the streams package for better organization and discoverability.
See PR #923.
Enhanced type checking for stream product operations with proper validation of operand types. Updated e2e tests to cover edge cases. See PR #947.
strings.Join Stream SupportThe strings.Join component now has an overloaded version that consumes streams.
// Original - join from list
pub def Join(data list<string>, sep string) (res string)
// New - join from stream
pub def Join(data stream<string>, sep string) (res string)
See PR #918.
Load environment variables from .env files with the new LoadEnv component.
import { os }
def Main(start any) (stop any) {
load os.LoadEnv
---
:start -> '.env' -> load:filename
load:values -> // dict<string> with parsed values
load:err -> // handle errors
}
Features:
.env in current directory if filename is emptydict<string>See PR #932.
Added comprehensive end-to-end test coverage for CLI templates created with neva new. See PR #934.
# Create and test new project
neva new my-project
cd my-project
neva run .
Refactored e2e tests to use e2e.Run for consistent output handling. This removes direct exec.Command usage and provides better error messages.
func Test(t *testing.T) {
out := e2e.Run(t, "run", "main")
require.Equal(t, "expected output\n", out)
}
See PR #948.
examples/ and/or e2e/ directoriesThis release represents a major step forward for Neva — especially with Go interop enabling real-world hybrid applications. Thanks to everyone experimenting with Neva and providing feedback.
Contributors: @emil14, @k1ngmang
Pull requests: #916, #918, #919, #920, #923, #927, #928, #931, #932, #934, #938, #939, #941, #943, #944, #947, #948, #949
Full Changelog: https://github.com/nevalang/neva/compare/previous...current
It’s been a while — the last release was on March 4th. This one is big: it brings the giant language feature, tagged unions, along with a wave of impr
It’s been a while — the last release was on March 4th. This one is big: it brings the giant language feature, tagged unions, along with a wave of improvements across the standard library and compiler internals. The project was “frozen” for a bit, but it’s back; thanks for sticking around and experimenting with Neva. This update lays important groundwork for future safety and ergonomics improvements.
Neva now supports tagged unions (discriminated unions, variant types). They let you define values that can take one of several forms — similar to Rust enums or algebraic sum types.
Some early checks for invalid use are already implemented, but full exhaustiveness checking isn’t there yet. See issues: #747, #751, #756.
Use union instead of enum. Tags can be tag-only or tag + single payload type.
// before (c-like enum)
type Day enum { Monday, Tuesday, Wednesday }
// after (tag-only union)
type Day union {
Monday
Tuesday
Wednesday
}
// tag + payload
type Input union {
Int int
Str string
None
}
Under the hood, unions are structs with a tag: string field. For example, printing a tag-only value like Day::Monday shows { "tag": "Monday" }. This representation is useful to understand pattern matching.
// tag-only sender
Day::Monday -> println
// wrapped sender (tag + data)
Input::Int(42) -> println
You can wrap any sender, e.g. Input::Int(foo:bar) -> .... It will wait to receive from foo:bar, wrap the value with the Int tag, and send it onward.
You can branch on union variants. Current matching supports routing; more exhaustive checks will come later.
src -> switch {
Input::Int -> handleInt, // message is int
Input::Str -> handleStr, // message is string
_ -> handleNone // message is something else
}
Generic “unionish” operators were replaced with real overloads per concrete type to enable tagged unions. See #832 for details.
// BEFORE (generic)
#extern(int int_add, float float_add, string string_add)
pub def Add<T int | float | string>(left T, right T) (res T)
// AFTER (overloaded)
#extern(int_add)
pub def Add(left int, right int) (res int)
#extern(float_add)
pub def Add(left float, right float) (res float)
#extern(string_add)
pub def Add(left string, right string) (res string)
stream_product example (it now runs as expected).fmt.Print and friends can now display more internal types (e.g., union values) without crashing.enum and introduces new constructs; check your code for naming collisions.Massive effort went into this one — mostly around tagged unions and cleaning up old compiler internals. Thanks to everyone experimenting with Neva, filing issues, and trying to make sense of the chaos.
new contributors:
https://github.com/nevalang/neva/pull/892https://github.com/nevalang/neva/pull/860read more: Release notes v0.32.0
full changelog: https://github.com/nevalang/neva/compare/v0.31.1...v0.32.0
Nothing published for this version
> Neva is a programming language where instead of writing step-by-step instructions, you create networks where data flows between nodes as immutable m
Neva is a programming language where instead of writing step-by-step instructions, you create networks where data flows between nodes as immutable messages, with everything running in parallel. After type-checking, your program is compiled into machine code and can be distributed as a single executable with zero dependencies.
It excels at stream processing and concurrency while remaining simple and enjoyable for general development. Future updates will add visual programming and Go interop to enable gradual adoption.
node -> ... with ? error-guard operator - when calling getFirstOutportName to get node:port sometimes we got :err which must've been skipped because of ?)--emit-ir added for neva run command, that allows to emit IR in yaml while running the program to get the exact same IR that is actually executed (implementation and API needs to be refactored in the future)
1.24golangci-lint updated to 1.64 (still no support for Go 1.24?)src.Scope (with fixes)This is an ambitious project maintained by a small group of enthusiasts. Your support by joining us will show interest and motivate us to continue.
Also, please give us a star ⭐️ to increase our chances of getting into GitHub's trending repositories and tell your friends about the project. The more attention Nevalang gets, the higher our chances of actually making a difference!
…for documentations (thanks our community). No backward incompatible changes so far.
Neva is a new kind of programming language where instead of writing step-by-step instructions, you create networks where data flows between nodes as immutable messages, with everything running in parallel by default. After type-checking, your program is compiled into machine code and can be distributed as a single executable with zero dependencies.
It excels at stream processing and concurrency while remaining simple and enjoyable for general development. Future updates will add visual programming and Go interop to enable gradual adoption.
This release extends standard library with new errors package plus contains some minor fixes for documentations (thanks our community). No backward incompatible changes so far.
errors packageNew stdlib package errors added with 3 public components:
def New(data string) (res error) - creates a new error with the given text.def Must<T, Y>(data T) (res Y) - converts a node that has an error outport to one that doesn't. It handles the error internally by panicking.def Lift<T, Y>(data T) (res Y, err error) - converts a node that doesn't have an error outport to one that does. The error outport is fictional and will always be silent.Lift// errors.Lift wraps handler so it behaves like a node with error outport.
def Main(start any) (stop any) {
lift errors.Lift<any, any>{Handler}
panic Panic
---
:start -> lift
lift:res -> :stop
lift:err -> panic
}
// Handler doesn't have error outport.
def Handler(data any) (res any) {
println fmt.Println<any>
---
:data -> '42' -> println -> :res
}
Must// errors.Must wraps handler so it behaves like a node without error outport.
def Main(start any) (stop any) {
println fmt.Println<any>
must_handle errors.Must<any, any>{Handler}
---
:start -> 'create_me.txt' -> must_handle -> 'success!' -> println -> :stop
}
// Handler have error outport.
def Handler(data string) (res any, err error) {
write_all io.WriteAll?
---
:data -> write_all:filename
'Hello, io.WriteAll!' -> write_all:data
write_all -> :res
}
constants.md by @eltociear in https://github.com/nevalang/neva/pull/852Full Changelog: https://github.com/nevalang/neva/compare/v0.30.2...v0.31.0
This is an ambitious project maintained by a small group of enthusiasts. Your support by joining us will show interest and motivate us to continue.
Also, please give us a star ⭐️ to increase our chances of getting into GitHub's trending repositories and tell your friends about the project. The more attention Nevalang gets, the higher our chances of actually making a difference!
Use proper .exe extension on windows by @hardliner66 in https://github.com/nevalang/neva/pull/840
Full Changelog: https://github.com/nevalang/neva/compare/v0.30.1...v0.30.2
This is an ambitious project maintained by a small group of enthusiasts. Your support by joining us will show interest and motivate us to continue.
Also, please give us a star ⭐️ to increase our chances of getting into GitHub's trending repositories and tell your friends about the project. The more attention Nevalang gets, the higher our chances of actually making a difference!
loongarch support added to install script by @Mr-Ao-Dragon in https://github.com/nevalang/neva/pull/837
loongarch support added to install script by @Mr-Ao-Dragon in https://github.com/nevalang/neva/pull/837neva.lock file is now released properly (improves neva build and neva get behaviour) by @Mr-Ao-Dragon in https://github.com/nevalang/neva/pull/836README.md improved for better promotionFull change-log: https://github.com/nevalang/neva/compare/v0.30.0...v0.30.1
This is an ambitious project maintained by a small group of enthusiasts. Your support by joining us will show interest and motivate us to continue.
Also, please give us a star ⭐️ to increase our chances of getting into GitHub's trending repositories and tell your friends about the project. The more attention Nevalang gets, the higher our chances of actually making a difference!
You can now use target-os and target-arch flags to specify operational system and architecture when using neva build command. This is only supported w
You can now use target-os and target-arch flags to specify operational system and architecture when using neva build command. This is only supported when --target=native (or omitted, which is the same). You must always use these flags in pair or omit both of them, they cannot be used in separate
neva build --target-os=windows --target-arch=arm64 examples/hello_world
New command neva osarch lists all possible combinations of target-os and target-arch values. At the moment of publishing this release, the list is the following:
aix/ppc64
android/386
android/amd64
android/arm
android/arm64
darwin/amd64
darwin/arm64
dragonfly/amd64
freebsd/386
freebsd/amd64
freebsd/arm
freebsd/arm64
freebsd/riscv64
illumos/amd64
ios/amd64
ios/arm64
js/wasm
linux/386
linux/amd64
linux/arm
linux/arm64
linux/loong64
linux/mips
linux/mips64
linux/mips64le
linux/mipsle
linux/ppc64
linux/ppc64le
linux/riscv64
linux/s390x
netbsd/386
netbsd/amd64
netbsd/arm
netbsd/arm64
openbsd/386
openbsd/amd64
openbsd/arm
openbsd/arm64
openbsd/ppc64
openbsd/riscv64
plan9/386
plan9/amd64
plan9/arm
solaris/amd64
wasip1/wasm
windows/386
windows/amd64
windows/arm
windows/arm64
This release closes #820 issue by improving the --help flag and help command (which are the same thing) by adding more information about build command, especially using --target (lists supported targets such as native, go, wasm, json and dot) and corresponding --target-os and --target-arch flags
As you can see, this is quite an ambitious project. Typically, such projects are backed by companies, but Nevalang is maintained by a very small group of enthusiasts. Your support by joining us will show interest and motivate us to continue.
Also, please give us a star ⭐️ to increase our chances of getting into GitHub's trending repositories and tell your friends about the project. The more attention Nevalang gets, the higher our chances of actually making a difference!
This is a small release that only contains a hot-fix for #816
This is a small release that only contains a hot-fix for #816
It fixes the case when irgen panicked because of missing Meta. It adds missing metadata and e2e test so we sure this specific case is always covered
Nevalang is a general purpose dataflow programming language with implicit parallelism and static typing that compiles to Go and machine code:
Nevalang is a general purpose dataflow programming language with implicit parallelism and static typing that compiles to Go and machine code:
This is another big release. This time we ship 2 big things and a lot of small ones. Number one big thing is support for anonymous ports in interfaces and another is solving DI drilling problem
// before
interface IDoer(data any) (sig any)
// after
interface IDoer(any) (any)
This allows to have interfaces with many more implementations and makes implementing an interface much simpler. All this leads to much better composability in the ecosystem.
This is however only supported for nodes with 1 inport and 1 outport.
The name is similar to React's "props drilling" problem
import { fmt } // package with dependency (with interface implementation)
def Main(start any) (stop any) {
foo Foo{printer fmt.Println<any>} // dependency injected
---
:start -> foo -> :stop
}
interface IPrinter(any) (any) // anonymous ports, baby
def Foo(start any) (stop any) {
bar Bar{printer IPrinter} // dependency passed through
---
:start -> bar -> :stop
}
def Bar(start any) (stop any) {
printer IPrinter // dependency defined
---
:start -> printer -> :stop
}
Nevalang supports dependency injection natively almost from the beginning. However, it was very limited up to this point. It was impossible to have intermediate layer between dependency provider and dependency consumer.
For example, Filter uses Split inside. Split needs dependency IPredicate (which is now any component that receives T and sends bool implements, thanks to anonymous ports interfaces feature!). And now you as a user can pass dependency to Filter, so Filter can bypass it right into split.
This was fundamental limitation for several years of development and solving it was a bit step for the language.
WARNING: You have to explicitly reference name of the dependency at each layer (in this case "printer") because otherwise compiler won't figure out where defined dependency comes from. This might be and might not be a temporary limitation, but that's the way it is.
Nevalang supports anonymous dependency injection similar to how it supports anonymous ports for interfaces (oh yeah) now, so if you don't have DI drilling in your case (Dependency flow is 1 level from parent to direct child), then feel free to pass deps
Node{Dep}. Remember it's only possible when there's 1 dependency so compiler don't have to guess
compiler.Error because any error at that step is internal/ with neva run and neva buildFilter component is re-implemented and is available to use again and all its e2e tests are active. New implementation handles .idx field of a stream<T> message properly (this caused a deadlock in specific programs)This release closes following issues
Fixes in analyzer - add missing support for binary and ternary expressions inside switch
switchFull Changelog: https://github.com/nevalang/neva/compare/v0.28.1...v0.28.2
Nothing published for this version
Sub operator fixed: left and right operands were confused
Sub operator fixed: left and right operands were confusedFull Changelog: https://github.com/nevalang/neva/compare/v0.28.0...v0.28.1
Nothing published for this version
Error messages improved in several places, by using correct location
fmt.Print component that works like fmt.Println but without the newline.http.Get renamed from resp to res for consistency with other stdlib components.strings.ToUpper and strings.ToLower components.Full Changelog: https://github.com/nevalang/neva/compare/v0.27.1...v0.28.0
Nothing published for this version
This is small release that only contains bug-fixes, new tests and documentation updates.
This is small release that only contains bug-fixes, new tests and documentation updates.
Special thanks @gavr123456789 for testing and feedback
Full Changelog: https://github.com/nevalang/neva/compare/v0.27.0...v0.27.1
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
After discord discussion a decision was made to increase priority for #717, this release fixes that issue.
After discord discussion a decision was made to increase priority for #717, this release fixes that issue.
Before you had to use deferred connections -> {} feature (or explicit locks) almost always when you wanted to use constant references or literals as network senders. Example:
:start -> { 'Hello, World!' -> println -> :stop }
Now alternative syntax is supported:
:start -> 'Hello, World!' -> println -> :stop
It means that now constant references and literals are valid parts of the chained connections.
By the way, old variant is still supported, 1) deferred connections are needed not just to block constants 2) because constants must be used outside of chained connections (e.g. inside binary/ternary/switch/etc expressions).
From now on you should always prefer using this new syntax, instead of old one, because it's easier to read and it has better performance. However, there might be cases where ->{} is exactly what you need.
Old variant
:start -> { 'Hello, World!' -> println -> :stop }
Hello World! const was sent to println in infinite loop from the program startup, but implicit lock node, that was waiting for the signal from start port, was inserted between then. Important note is constant sender was not waiting for anything and instead we had to defer receiving event, to guarantee that we will print exactly once.
New variant
:start -> 'Hello, World!' -> println -> :stop
Hello, World! const waits for signal from start port and then sends a message to print.
Range expressions work in a similar way
:start -> 1.100 -> ...
This works thanks to new builtin.NewV2 (name is temporary) native component that behaves almost like builtin.New except instead just sending configuration message in infinite loop and being only by the speed of receivers, NewV2 has input port sig - it awaits for input signal and sends a message to receivers, then blocks until new sig message comes in, and so on and so forth.
Full Changelog: https://github.com/nevalang/neva/compare/v0.26.0...v0.27.0
Nothing published for this version
Nothing published for this version
Nothing published for this version
Documentation now exists in the docs folder at the root of the main Nevalang repository. The website documentation is deprecated until we implement ge…
It's been 4 months since the last release, with major changes across all parts of the language - from syntax to runtime implementation, including new features, stdlib components, and bug fixes.
def KeywordYou are now must use def keyword to define components.
def Main(start any) (stop any) {
:start -> :stop
}
The word def is short and common (used in Python, Ruby, Clojure, Scala, Elixir, Nim, Crystal, Groovy) and it means "define," which has a broader meaning. The word flow led to confusion because the abstraction is called "component." But thanks to @ajzaff for the suggestion anyway
Due to the addition of binary and ternary expression senders, we had to reserve () and select a different syntax for deferred connections.
:start -> (42 -> println)
:start -> { 42 -> println }
Structs are now their own type of sender, rather than a modifier for other senders.
someStruct.someField -> println
someStruct -> .someField -> println
This allows for implementing struct selectors on the receiver side in connections with multiple receivers.
s -> [
.field1 -> r1
.field2 -> r2
]
Note that you don't have to write
foo -> .bar -> .baz -> ...; you can instead writefoo -> .bar.baz -> ...
You are now allowed to use syntax sugar for using Range component
:start -> 1..100 -> ...
Range is a type of sender, so it might be used anywhere, where any other sender is expected (with the respect of type-safety, ofcourse)
Will emit stream<int> of messages from 1 to 99 (range is exclusive)
You can now write binary expressions as you would in other languages.
(1 + 2) -> println
Please note that you must use parentheses, as Nevalang currently lacks operator precedence. For now, nested binary expressions look like this:
((1 + 2) * 3) -> println
14 binary operators are implemented: 6 arithmetic, 6 comparison, and 2 logical.
+ - * / % **
== != > < >= <=
&& ||
Syntax is simple:
(sender_1 OPERATOR sender_1)
sender_1 and sender_2 can be any valid senders: port addresses, constant references, message literals, other binary expressions, etc.
The compiler understands these expressions and desugars them into regular connections using stdlib components. You can check builtin/operators.neva to see their API. They all follow the same pattern:
def Op(left T1, right T2) (res T3)
Both operands must be compatible with their operator, or the compiler will throw an error.
ReduceThe higher-order component Reduce has been modified, and the interface for the reducer now looks like this
interface IReduceHandler<T, Y>(left T, right T) (res Y)
As you may have noticed, many binary operators are actually reducers. Thanks to @ajzaff for this idea.
Related issues: #742 and #721
Similar to binary expressions, ternary expressions use the ? : operator, as in most languages.
(condition ? ifValue : elseValue) -> ...
All 3 parts are senders, so all sender types are supported, including other ternary and binary expressions. The condition sender must emit bool, and the If and Else parts must both be compatible with the receiver, otherwise the compiler will throw an error.
Similar to binary operators, the ternary operator is just syntactic sugar for using the Ternary component:
def Ternary<T>(if bool, then T, else T) (res T)
For both binary and ternary expressions, you may explicitly use operators as components if the expression-based syntax doesn't cover your case.
Switch statementAnother type of sender was added to simplify the use of the Switch component. This is necessary when you need to trigger different branches of the network based on the value of an incoming connection. The syntax is as follows:
s -> switch {
c1 -> r1
c1 -> r2
c1 -> r3
_ -> r4
}
Here s means sender, which could be any sender (including binary and ternary expressions). c1, c2, c3 are "case senders" - they are also senders, and any senders will work as long as they are type-safe. Finally, _ is the default sender. The default branch is required, making each switch expression exhaustive. The compiler ensures that the incoming s -> and all c and _ senders are compatible with their corresponding receiver parts.
If one branch is triggered, other branches will not be (until the next message, if the corresponding pattern fires) - one way to think about this is that every branch has a "break" (and there's no way to "fallthrough").
I don't like this explanation because it's control-flow centric, while Nevalang's switch is pure dataflow, but it makes sense as an analogy.
The switch statement is syntactic sugar for the Switch component:
def Switch<T>(data T, [case] T) ([case] T, else T)
You are allowed to use
Switchas a component, if you need to, but prefer statement syntax if possible
To better understand the switch statement, let's look at a few examples:
// simple
sender -> switch {
true -> receiver1
false -> receiver2
_ -> receiver3
}
// multiple senders, multuple receivers
sender -> switch {
[a, b] -> [receiver1, receiver2]
c -> [receiver3, receiver4]
_ -> receiver5
}
// with binary expression senders
sender -> switch {
(a + b) -> receiver1
(c * d) -> receiver2
_ -> receiver3
}
// nested
sender -> switch {
true -> switch {
1 -> receiver1
2 -> receiver2
_ -> receiver3
}
false -> receiver4
_ -> receiver5
}
// as chained connection
sender -> .field -> switch {
true -> receiver1
false -> receiver2
_ -> receiver3
}
Related to #725
In this example
sender -> switch {
[a, b] -> [receiver1, receiver2]
c -> [receiver3, receiver4]
_ -> receiver5
}
If the sender message is equal to either a or b, it will be sent to both receiver1 and receiver2. You can also have multiple senders and one receiver, or one sender and multiple receivers.
switch is a "router," not a "selector." It can only redirect incoming messages to a branch based on a condition (equality comparison). But what if we want to select one of the possible options instead of redirecting the incoming message? For this, another component called match will be implemented. It will work similarly to switch but act as a selector rather than a router.
num -> match {
42: 'a'
43: 'b'
_: 'c'
} -> println
Note the outgoing
->thatswitchdoes not have.
WARNING: match is NOT implemented yet.
Related to #726 and #747
Tap componentSometimes component needs to receive data, perform some action and pass that data further. However, due to impossibility to reuse same sender twice or more, it leads to need for explicit locks. Deferred connections do not cover this case. Explicit lock make network harder to reason about. Tap is a higher-order component, that implements this logic for you. All you need to do, is to provide dependency node, thar receives data and sends a signal when finishes. Signal could be of any type, so no need for dealing with locks manually.
def Tap<T>(data T) (res T)
For example here we need to pass data to FirstLine and then to SecondLine, but FirstLine only sends a signal, that it finished, so we need to lock data and send it further. This is tedious and error prone, so we can use Tap to handle this case:
def Next2Lines(data int) (sig any) {
first Tap<int>{FirstLine}
dec Dec<int>
second SecondLine
---
:data -> first -> dec -> second -> :sig
}
One of the biggest challenges for a long time was overcoming various race conditions and out-of-order delivery. Finally, a proper design has been found. As with all elegant solutions, its power lies in its simplicity, bringing not just predictability but also much better performance.
The new runtime design is "connectionless." After compilation, a Nevalang program consists of runtime functions passing messages through channels. There are no more intermediate message-passing goroutines that caused concurrency issues. This is achieved through graph reduction. After IR generation, we strip intermediate connections, leaving only runtime functions. The runtime also has a better API, making it easier than ever to work with runtime functions.
Issues solved with new design:
Please note that this doesn't mean your code will be free of race conditions. It means they are not related to the runtime implementation but rather to your program logic. There are still some issues at the stdlib level, such as #754.
Generating Go and compiling it with the Go compiler is now the only way to run Nevalang programs. You don't have to do it manually; neva build will call go build under the hood, so you'll get a binary (unless you pass --target=go). The command neva run will also run the built executable and clean it up afterward. This change simplifies the project, as the interpreter required duplicated functionality that the compiler already had, but without the ability to reuse it. This takes away some possibilities, but we must choose a direction, and for Neva, it's compilation to Go.
Documentation now exists in the docs folder at the root of the main Nevalang repository. The website documentation is deprecated until we implement generating HTML from markdown in the docs folder. The documentation has been updated, but some parts are already outdated due to the rapid changes in the language at this early stage. Please join our Discord server if you have any questions or problems.
The compiler now handles more potential errors with static semantic analysis. Error messages have been improved, so in most cases, you should have the location of the error. Error messages are still far from perfect; they are a complex issue on their own, but we have some ideas on how to handle them properly. Several bugs were also fixed. Finally, many things were refactored to make the code cleaner.
Full Changelog: https://github.com/nevalang/neva/compare/v0.25.0...v0.26.0
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
It was almost a month after we've released the last version of the language. All this time we've been doing some heavy-lifting. We still need to do it
It was almost a month after we've released the last version of the language. All this time we've been doing some heavy-lifting. We still need to do it, but bright future is closed day by day. So, what was going on?
Behold, this is the biggest Nevalang release so far!
In order to fix out-of-order delivery issue with fan-in connections we've completely changed the way runtime operates.
New algorithm properly handles fan-in messages thanks to atomic counter that is used to mark each message when it's sent. With this approach we can serialize messages and deliver them in the same order they was sent. However, out-of-order might still happen in more complex cases. Please see #689 for more details.
With massive runtime rewrite we've also changed how runtime functions interact with the runtime. New API is much simpler and safe than the old one. You don't have to handle context cancelation manually or iterate over array port slots. No more interactions with the raw go channels. Checkout how runtime functions look now, it's about x1.5 less code!
With new design runtime can properly handle fan-in connections but can't handle fan-out. Thankfully this is solved by removing fan-out from low-level program representation completely. Fan-out connections now only exist as syntax sugar in high level representation. Compiler desugarer transforms fan-out connections to regular pipelines with new FanOut component in standard library. This component has the following signature:
pub flow FanOut(data any) ([data] any)
Implemented algorithm that can turn IR (low-level program representation) graph into much smaller but functionally equal one. It is disabled now and needs a little bit more testing. We will enable it by default or under feature flag in next releases.
Last, but not least - with new runtime Nevalang v0.25 is faster than v0.24 by approximately two orders of magnitude. I didn't do any benchmarks but examples/99_bottles runs x200 times faster that before... And this is without graph reduction enabled!
Crazy thing about this is that this improvement is accidental! Our goal was to me it correct, not fast. However, performance improvement can be seen by naked eye.
Another funny thing is that now, when runtime works so fast, it's possible to spot new issues that cannot occur when program works slowly. New issues are described in #689.
Nothing published for this version
Upgrade command added by @dorian3343 in https://github.com/nevalang/neva/pull/608
Product by @Catya3 in https://github.com/nevalang/neva/pull/641Zip by @Catya3 in https://github.com/nevalang/neva/pull/642sync.WaitGroup by @Catya3 in https://github.com/nevalang/neva/pull/628std components by @dorian3343 in https://github.com/nevalang/neva/pull/649For and Map components by @emil14 in https://github.com/nevalang/neva/pull/619Full Changelog: https://github.com/nevalang/neva/compare/v0.23.0...v0.24.0
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
One column per month.