Skip to content
Digital Nestby Ulises Jeremias

Core Team @ V · vlang/v · scientific · reactive · CI

V Ecosystem — Fast, clear, scientific

Computational lab — four libraries, one Action, and a language. Verified contributions (no vanity counts), diagrams as code, pure-V backends by default.

Explore ecosystemVSL pure-V →vlang/v ↗

Digital Nest · V world

Computational lab — Core Team, proof over claims

I’m Core Team Member @ V. The site shows contributions with links to repos, commits, and reviewed PRs — not vanity counts. V is the language; VSL, VTL (V Tensor Library), RxV, and setup-v are the tools that make it usable for science, tensors, streams, and CI.

“Simple enough for a Friday afternoon. Fast enough for a production pipeline.” — V ecosystem
Core Team @ VVerified commits in vlang/v, vsl, vtl, setup-v + author of ulises-jeremias/rxv
Scientific focusPure-V BLAS/LAPACK, autograd, fractals — testable numerics over benchmarks theatre
Installv install vsl · v install vtl · v install ulises-jeremias.rxv
How this page verifies claims (and where Veasel fits)
  • Links point to github.com/vlang/* and ulises-jeremias/rxv — each card links to its repo, not to stars.
  • Diagrams are HTML/CSS/SVG authored here — no embedded screenshots that hide state. Reduced-motion shows static fallbacks.
  • Veasel (V mascot) is only included if vlang/v-mascot/LICENSE explicitly permits it with attribution. Otherwise this site uses an original V-inspired illustration and states the ambiguity plainly.
  • See src/data/project-worlds.ts for world metadata and src/data/routes.ts for canonical URLs.

01 · language

V — language core

V is a compiled language built to be simple and fast. One self-hosted compiler, C output, tcc bootstrap, predictable performance.

  • Static typing, sum types, option/result, no null
  • C interop without header pain, fast incremental
  • vfmt, vvet, docs via doc/comment → markdown

02 · scientific

VSL — pure-V scientific stack

High-performance numerics without system deps. Pure-V BLAS/LAPACK ships by default; drop in OpenBLAS/LAPACKe with a flag when you need peak throughput.

  • BLAS Level 1-3 + LAPACK (pure-V, 0 deps)
  • Flags: -d vsl_blas_cblas / -d vsl_lapack_lapacke
  • Stats, FFT, optimization, visualization (Plotly style)

03 · tensors

VTL — tensors & autograd

Tensor[T] with slicing, broadcasting, and reverse-mode autograd. Build arbitrary graphs — then let nn layers compose them for you.

  • Context + Variable + gates → backprop()
  • Sequential API: Linear/Conv2D/LSTM/Attention
  • Optimizers: Adam, AdamW, RMSProp, AdaGrad, SGD

04 · reactive

RxV — observables as channels

Each operator spawns a lightweight thread and connects via chan Item[T]. No scheduler, no hidden state — just V channels.

  • Creating: just / range / from_slice / interval / timer
  • Filtering, transforming, combining
  • Error + completion as first-class events

05 · CI

setup-v — one line, every runner

The Action resolves version (tag, branch, commit, or .v-version), detects arch, restores cache, installs the binary, and verifies v version.

  • Uses PAT-less binary fetch for tags (no rate-limit pain)
  • Arch-aware (x64, arm64) with warning fallback
  • Cache key: version + os + arch → ~seconds restores

Architecture

One toolchain, five surfaces

V compiles it. VSL and VTL compute it. RxV streams it. setup-v installs it. Tab or use a screen reader to walk each node — SVG has title, desc, and keyboard focus per surface.

V ecosystem — core, libraries, reactive and CICentral V node at top center, four library nodes below (VSL, VTL, RxV), and setup-v pipeline at bottom spanning full width. Arrows show dependencies: libraries depend on V, RxV is independent channel pipeline, setup-v distributes all.V — vlang/vCompiler, formatter, checker, docs. Single bootstrap.languageVcompiler · tooling · vlang/vVSL — vlang/vslPure-V BLAS/LAPACK, stats, FFT, visualization.scientificVSLBLAS · LAPACK · fractalsVTL — vlang/vtlTensor[T], autograd graph, Sequential.tensorsVTLautograd · nn · VSLRxV — ulises-jeremias/rxvObservable[T] pipelines via chan Item[T].reactiveRxVchannels · operatorssetup-v — vlang/setup-vOne-line install for every runner.CI · actionsetup-vversion · arch · cache · PATH · vlang/setup-v@v1uses: vlang/setup-v@v1
Vcompiler · tooling
VSLscientific · BLAS
VTLtensors · autograd
RxVreactive · channels
setup-vCI · action

Structure: V at the top, VSL/VTL/RxV in the middle row, setup-v distributing at the bottom. Arrows show dependency flow.

All projects MIT. Install V via vlang/setup-v@v1 and add libraries with v install vsl / v install vtl / v install ulises-jeremias.rxv.

Ecosystem

Six surfaces — one language

V is the root. VSL and VTL handle numbers and learning. RxV handles time. setup-v and Awesome V handle distribution and discovery. Each ships MIT, each stands alone.

V

vlang/v

↗

Simple, fast, safe compiled language — Go-like syntax, C-like speed, single bootstrap.

Core Team — compiler, tooling, docs, ecosystem

  • Single-file bootstrap via C + tcc
  • Immutable by default, fast compile
  • 4M+ LoC compiled <1 s
vlang/v → (opens in new tab)

VSL

vlang/vsl

↗

V Scientific Library — pure-V BLAS/LAPACK, linear algebra, stats, visualization.

Maintainer — pure-V backends, fractals, benchmarks

  • Pure-V default, zero deps
  • Optional CBLAS/LAPACKe
  • Sierpinski + Mandelbrot + Julia
vlang/vsl → (opens in new tab)

VTL

vlang/vtl

↗

V Tensor Library — n-dimensional Tensor[T], autograd, neural networks, VSL-backed LA.

Maintainer — Tensor core, autograd graph, Sequential API

  • Reverse-mode autograd
  • Layers, losses, optimizers
  • Broadcast + map/reduce
vlang/vtl → (opens in new tab)

RxV

ulises-jeremias/rxv

↗

ReactiveX for V — generic Observable[T], channel pipelines, composable operators.

Author — channels, operators, specs

  • chan Item[T] per operator
  • filter / map / merge / reduce
  • Zero dependencies
ulises-jeremias/rxv → (opens in new tab)

setup-v

vlang/setup-v

↗

GitHub Action for V — version, arch, cache, install, verify. One line, every OS.

Maintainer — install flow, caching, arch detection

  • vlang/setup-v@v1.7
  • Version file + cache
  • Linux / macOS / Windows
vlang/setup-v → (opens in new tab)

Awesome V

vlang/awesome-v

↗

Curated catalog — libraries, tools, and community picks for the V ecosystem.

Curator — scientific + template picks

  • Community curated
  • Scientific + templates
  • CC0 1.0 list license
vlang/awesome-v → (opens in new tab)

02 · VSL

Pure-V by default, C when you ask

VSL ships pure-V BLAS/LAPACK with no system deps. Flip a compile flag and it delegates to OpenBLAS / LAPACKE. Deterministic fractals (Sierpinski, Mandelbrot, Julia) prove both paths pixel-identical — with graceful CPU fallback and prefers-reduced-motion support.

VSL — fractal backends and pure-V pipelineLeft: Sierpinski triangle levels showing deterministic subdivision. Right: two backend pills (Pure V default, CBLAS/LAPACKe optional) feeding into LA pipeline via arrow. Bottom: visualization row with mandelbrot/julia mini previews.fractal · deterministicSierpinski · lvl 4backends · flag selectLA pipelinePure V — zero depsPure Vdefault · zero deps✓CBLAS — -d vsl_blas_cblasOpenBLAS-d vsl_blas_cblasoptionalLAPACKE — -d vsl_lapack_lapackeLAPACKE-d vsl_lapack_lapackeoptionalvisualizationPlotly-style · 2D/3D · FFT · stats
Pure V default · Zero-dep deploy, cross-platformOpenBLAS (CBLAS) -d vsl_blas_cblas · Max throughput when C libs availableLAPACKE -d vsl_lapack_lapacke · LAPACK at C speed

Linear algebra as compiled V

Matrices, vectors, eigen, SVD, QR, Cholesky — same APIs whether pure-V or C-backed. Tests are the spec; benchmarks prove parity.

  • Level 1-3 BLAS, LAPACK solvers, eig, SVD
  • MPI + optional OpenCL (roadmap) — same Tensor data
  • v run benchmarks/blas_bench.v to compare backends

Visualization without magic

Scientific plotting with a Plotly-shaped API. Heatmaps, histograms, spectrograms — CPU path first, acceleration opt-in.

  • Deterministic palettes, no hidden state
  • Graceful CPU fallback, reduced-motion static preview
  • Examples: FFT, geometry playground, GM binning

Try locally: v install vsl → v run examples/*/main.v. Docs: vlang.github.io/vsl ↗. Source: vlang/vsl ↗.

03 · VTL

Tensors that remember their graph

Every Tensor[T] is a view. Wrap it in a Variable via Context and each op records a gate. Call backprop() and gradients flow backward — scalars first, then generalized. Hover or focus the graph to see forward (solid) vs backward (dashed) edges.

VTL — autograd forward and backward graphForward pass left to right: Input Tensor[64,784] via Context variable, Linear 784→256, ReLU, Linear 256→10, MSE loss. Backward pass right to left dashed: gradients propagate through gates to variables. Optimizer step at far right. Keyboard focus per node shows shape and gate type.forward →← backwardInput — zeros[64,784] — ctx.variable()inputTensor[64, 784]ctx.variable()Linear 784→256 — gate matmullayer 1Linear784 → 256200,960 paramsReLU — gate relu — elementwise max(0,x)ReLUgateLinear 256→10 — classifierslayer 2Linear256 → 10logitsLoss — scalar — backprop()!LossMSE / CrossEntropy.backprop()!Target — zeros[64,10]target[64, 10]ground truthoptimizer · updateAdam · AdamW · RMSProp · SGDlr + build_params(layers) + update()!
vtl Tensor[T] · create, slice, reshape, transpose, broadcastvtl.autograd Context, Variable, gates, backprop()vtl.la VSL-backed LA: matmul, solve, SVD, QR, Choleskyvtl.nn Layers, losses, internal init (Kaiming/Xavier)vtl.nn.models Sequential builder — input → linear → forward

From Tensor[T] to graph

Create zeros, ones, or from_slice. Slice and broadcast without copy. When you need learning, wrap via Context and let every op emit a gate.

mut ctx := autograd.ctx[f64]()
mut x := ctx.variable(vtl.zeros[f64]([64, 784]))
y := model.forward(x)!
loss.backprop()!

Neural nets are just compositions

Sequential piles Linear → Activation. Losses are variables too — pick MSE, BCE, or CrossEntropy and the graph knows how to differentiate it.

  • Sequential: input([784]).linear(256).linear(10)
  • Losses: MSE / BCE / CrossEntropy / Huber
  • Optimizers: Adam, AdamW, RMSProp, AdaGrad, SGD + schedulers

04 · RxV

Streams as channels, operators as threads

Create an Observable[T] and chain: source → filter → map → merge/reduce → subscriber. Each step spawns one thread, communicates via chan Item[T], and forwards error + completion. Deterministic, generic, zero-deps.

RxV — source through operators to subscriberHorizontal pipeline: source range emits 1..10, filter even, map double, merge with timer channel, reduce sum, subscriber for_each prints sum. Arrows show item flow; error and completion follow same channel. Bottom row shows thread-per-operator model via chan Item[T].pipeline · chan Item[T]Source — rxv.range(1,10)sourcerange1 → 10emits 10 itemsfilter — v % 2 == 0filterv % 2 == 0keeps 5 · drops 5.filter(fn)map_ — v * 2 — free function due to V genericsmap× 25 items → doubledmap_[T,T](…)reduce — sum — acc 0reducesumacc 0 → 60reduce_[T,U]Subscriber — for_each — done channelsubscribefor_eachprints 60 · done<- donethread per operator · chan Item[T]Each operator spawns 1 lightweight thread → reads chan[T], writes chan[T] → error/completion are Item tags → for_each blocks on done.example · sum even doubles 1..10range(1,10) → filter(even) → map(×2) → reduce(0, sum) → for_each(print)Output: Sum 1..10 even×2 = 60(5 items: 4,8,12,16,20 → sum)
Creatingjust · from_slice · range · interval · timer · defer_
Filteringfilter · take · skip · take_last · first
Transformingmap_ · flat_map · scan · buffer · group_by
Combiningmerge · concat · zip · combine_latest
Utilityreduce_ · for_each · distinct · retry

Why channels?

V channels are typed, buffered, and cheap. RxV leans on them — no global scheduler, no hidden queue. If you know go or spawn, you know RxV.

  • ObservableImpl[T] generic over any T
  • Errors as Item[T]{ error: IError }
  • Item[T]{ is_closed: true } for completion

From V generics to free fns

V doesn’t allow generic methods with extra type params, so .map is rxv.map_[T,U](mut obs, fn). Verbose once, clear forever — types stay explicit.

mut obs := rxv.range(1, 10)
mut evens := obs.filter(fn (v int) bool { return v % 2 == 0 })
mut doubled := rxv.map_[int,int](mut evens, fn (v int) ?int { return v*2 })
done := doubled.for_each(…)
_ = <-done

Install: v install ulises-jeremias.rxv → import ulises_jeremias.rxv. Docs: ulises-jeremias/rxv ↗. Operators reference: docs/OPERATORS.md.

05 · setup-v

From workflow line to verified binary

uses: vlang/setup-v@v1 resolves version, detects arch, restores cache, fetches the prebuilt binary, writes it to PATH, and exposes outputs. On exotic arches it warns and falls back gracefully — no sudo, no build unless you ask.

setup-v — GH Action pipeline 5 stepsHorizontal five-stage pipeline: Resolve version, Arch detection, Cache restore, Install binary, Verify. Each stage is a node with input and output; cache hit short-circuits install; error paths use rollback.pipeline · 5 stages · cache-awareworkflow.yml- uses: vlang/setup-v@v1with: version / arch / cacheruns: 5 stages →Resolve — version input or .v-version1resolveVersionstable / nightly.v-version→ 0.4.9Arch — x64 / arm64 — fallback warning2archArchx64 · arm64detect + warn→ linux/amd64Cache — key: version + os + arch3cacheCacherestorekey: v+os+archhit → skipInstall — fetch + unpack + PATH4installFetchbinary+ PATHVerify — v version + outputs5verifyVerifyv -voutputsoutputs · used by later steps→ v install or v testrunners
1Resolveversion / .v-version / stable2Archdetect x64 / arm643Cacherestore cached binary4Installfetch + unpack + PATH5Verifyv version + outputs

Cache is the feature

GitHub cache keyed by version+OS+arch. Cache hit skips the binary download — CI goes from ~40s to ~4s. Core Team keeps prebuilts for x64 + arm64 on every tag.

- uses: vlang/setup-v@v1
  with:
    version: '0.4.9'  # or .v-version
    cache: true

Version is flexible

Accepts tag (0.4.9), branch (master), commit SHA, or file path (.v-version). No token needed for tags — uses blob fetch.

  • Also: latest, stable, semver range
  • Self-hosted: respects pre-installed V
  • Post-job: cleanup via action.yml post entry

Action: vlang/setup-v ↗ · Marketplace:vlang/setup-v@v1 · Cache docs via README.md inputs table.

License verification

Verified licenses — MIT with responsible Veasel policy

This site and the V ecosystem share MIT. Veasel (mascot) is included only ifvlang/v-mascot/LICENSE allows it with attribution; otherwise use an original V-inspired illustration (non-derivative) — no Veasel binary is embedded here.

website (this site)

MITLICENSE — Copyright (c) 2025-2026 Ulises Jeremias Cornejo Fandos

V feature content and /v page under the site MIT license.

V + VSL + VTL + setup-v + Awesome V

MIT / CC0 (awesome-v list)vlang/* LICENSE (MIT); awesome-v CC0 1.0

Core V libraries maintained with the V community. awesome-v catalog is CC0.

RxV

MITulises-jeremias/rxv/LICENSE (MIT)

ReactiveX for V by Ulises Jeremias. Zero dependencies, public API MIT.

Veasel / V mascot

CC BY-NC 4.0 — not used commercially heregithub.com/vlang/v-mascot

This site does not ship Veasel assets. Commercial or derivative use requires checking v-mascot LICENSE (CC BY-NC). Prefer original V-inspired diagrams.

v ↗ ·vsl ↗ ·vtl ↗ ·rxv ↗ ·setup-v ↗ ·awesome-v ↗