KurrentDB-backed Microsoft Agent Framework integration: chat history, evals (per-turn and session-level), memory, and workflow checkpointing.
Lyntai core: every domain's contracts and engines — LLM provider abstraction with routing + streaming-aware fallback, the media generation platform, prompt registry, scoring/eval and run traces, long-term memory (named engines over a decaying graph), durable jobs, the tool loop, guards, the secret vault, storage domain interfaces, and DI wiring (AddLyntai). Depends only on the DI and Logging abstractions — adapters live in separate Lyntai.* packages.
The MathEvaluator .NET library allows you to evaluate and compile any mathematical expressions from a string dynamically. It supports a wide range of operations and allows for the use of custom variables, operators, and functions. The evaluator can be configured for different contexts, such as scientific or programming math expressions, making it highly versatile for various use cases. This flexibility, combined with its high performance, makes it an excellent choice for developers needing a robust mathematical evaluation tool.
Source-only Roslyn compiler for com.IvanMurzak.CodeExec. Compiles inside your project against YOUR Microsoft.CodeAnalysis.CSharp (3.8 or newer) — add that package yourself.
Public contract (IEvalContext, EvalOptions, SafeModeLevel, WarmupResult, exceptions) for NeyTI.EvalEngine. Referenced directly by consumers, which is why it is shipped separately instead of merged into the core assembly.
Advanced Calculator that can be implemented easily supports the following +*-/^ operations sin,cos,tan,sin-1,cos-1,tan-1,ln,log10 functions !,ncr,npr operations X,Y,Z variables
Embedded browser panes for Ryn — secondary native webviews (WKWebView/WebView2/WebKitGTK) positioned inside a window, with navigation, zoom, DevTools, eval, and per-pane sessions
Fuaran resolved-style observability concrete observers — BrowserStyleObserver (Fable, getComputedStyle-backed, effective-background composite walk, rAF-debounced) and InMemoryStyleObserver (pure .NET, drives Expecto tests + the eval gate). Companion of Fuaran.UI.StyleObserver.Abstractions; shares all flag-derivation logic. Apache-2.0 licensed.
Fuaran layout-observability concrete observers — BrowserLayoutObserver (Fable, ResizeObserver-backed, rAF-debounced) and InMemoryLayoutObserver (pure .NET, drives Expecto tests + the eval gate). Companion of Fuaran.UI.LayoutObserver.Abstractions; shares all flag-derivation logic. Apache-2.0 licensed.
Host-neutral validated-exemplar seam for Fuaran content pipelines. `decodeExemplar` admits a canonical wire-format JSON string into a Node tree through three gates — decode (Fuaran.UI.Ops.JsonDecode), pre-emit-validate (Fuaran.UI.PreEmitValidate), and a canonical decode/encode round-trip fixed point — returning the decoded Node plus its canonical bytes, or the decoder's typed AI-recovery hints. The integrity core a docs site, an eval seed corpus, or a fuaran-wire fence pipeline reuse to make a bad example a build failure rather than a published invalid tree. No Giraffe / ASP.NET / routing / markdown dependency — rendering and page assembly stay with the host. Apache-2.0 licensed.
SQLite implementations of every Lyntai storage domain (key-value, versioned prompts, conversations, task-scoped memory with FTS5 trigram recall, curated memory, the memory engine's graph, scores, run traces, durable jobs) plus persistent backends for the response cache, usage tracker, and semantic-memory vector store — Dapper + FluentMigrator, wired via builder.UseSqliteStorage(path).
MCP in BOTH directions. Exposes a Model Context Protocol server's tools as Lyntai ITools so the tool loop can call them, and hosts the app's registered ITools as an ephemeral, localhost-only MCP server for a CLI that runs its own agent loop. Wired via builder.AddMcpTools(...) and builder.AddMcpToolHost(...). Absorbed Lyntai.Tools.Mcp.Hosting, which pinned the same dependency and is retired.
PostgreSQL implementations of the Lyntai storage domains (key-value, conversations, task-scoped memory with pg_trgm substring recall, curated memory, the memory engine's graph, scores, run traces, versioned prompts, durable jobs) plus persistent backends for the response cache, usage tracker, and semantic-memory vector store (pgvector) — Npgsql + Dapper + FluentMigrator, wired via builder.UsePostgresStorage(connectionString). Every object is lyntai_-prefixed so it can share a consumer database.
Windows DPAPI machine/user binding for the Lyntai secret vault: a DpapiSecretProtector (System.Security.Cryptography.ProtectedData) and builder.AddDpapiSecretVault(...), which wires an envelope vault whose DEK is sealed to this host by DPAPI and recoverable off-machine via a recovery key. Windows-only at runtime (guarded); the portable envelope crypto lives in Lyntai.Core.
Winforms Charting NET60 x64 Development (Windows Desktop) Our x64 assembly is best for VS 2022. Note that continued use of this package requires acceptance of our license PE9LICENSE.TXT. Watch a short video: https://www.youtube.com/watch?v=yhC0BwEm8M8 Download the no-hassle eval at https://www.gigasoft.com to get our example projects. ProEssentials is for developing large mission critical visualization projects that render many types of highly interactive charts in proprietary fashion. ProEssentials is GPU accelerated (Direct3D / DirectX) and performance and quality optimized to meticulously and quickly render your data in 2D, 3D, real-time, polar, pie and smith/admittance charts. Gigasoft's engineers will quickly answer your questions and provide programming services as needed. Just ask. ProEssentials provides charts packed with annotations and proprietary views mostly free of overlapping text and odd behaviors, automatically. Extensive flexible easy to use annotations. Intelligent multiple y and x axes that automatically show/hide as needed, automatically optimizing screen real-estate. Intelligent date time handling from years to milliseconds seconds. To summarize, highest quality rendering and end-user experience independent of shape/size chart and properties used.
Lyntai LLM provider for in-process local inference of GGUF models via LLamaSharp (llama.cpp). References LLamaSharp managed only — the consuming app picks an LLamaSharp.Backend.* (Cpu/Cuda/Vulkan/Metal) matching its hardware. Wired via builder.AddLocalProvider(modelPath).
动态表达式,可以执行表达式字符串,可以合并表达式内容
Zero-dependency in-memory implementations of the Lyntai storage domains — for tests, ephemeral/serverless use, and as the second backend proving the domain-interface seam (mix it with Lyntai.Storage.Sqlite per domain via DI). Wired via builder.UseInMemoryStorage().
The tinyeval command for .NET: runs the evals in evals/*.sh against your app and says which replies pass.
The recommended STARTING set for Lyntai — not the whole library (5 of 11 packages). You get: the core library, the basic backends (the claude/codex CLIs, any OpenAI-shaped endpoint for chat, embeddings or reranking, Ollama's native API, an in-process model2vec embedder), both halves of MCP, IN-MEMORY storage, and FILE storage you switch on by naming a root (UseFileSystemStorage). Two things to know: nothing persists until you name that root (UseInMemoryStorage keeps storage in process), and for a database ADD Lyntai.Storage.Sqlite (or .Postgres); and image/video/audio generation is NOT included — add Lyntai.Generation. Also opt-in: Lyntai.Providers.LlamaSharp (in-process GGUF), Lyntai.Providers.Onnx (in-process transformers) and Lyntai.Secrets.Dpapi (Windows). Everything left out is left out because it drags a native payload, a platform-specific API, or a dependency an application that did not ask for that feature should not carry.
WPF Charting NET60 x64 (Windows Desktop) Our x64 assembly is best for VS 2022. Note that continued use of this package requires acceptance of our license PE9LICENSE.TXT. Watch a short video: https://www.youtube.com/watch?v=yhC0BwEm8M8 Download the no-hassle eval at https://www.gigasoft.com to get our example projects. ProEssentials is for developing large mission critical visualization projects that render many types of highly interactive charts in proprietary fashion. ProEssentials is GPU accelerated (Direct3D / DirectX) and performance and quality optimized to meticulously and quickly render your data in 2D, 3D, real-time, polar, pie and smith/admittance charts. Gigasoft's engineers will quickly answer your questions and provide programming services as needed. Just ask. ProEssentials provides charts packed with annotations and proprietary views mostly free of overlapping text and odd behaviors, automatically. Extensive flexible easy to use annotations. Intelligent multiple y and x axes that automatically show/hide as needed, automatically optimizing screen real-estate. Intelligent date time handling from years to milliseconds seconds. To summarize, highest quality rendering and end-user experience independent of shape/size chart and properties used. First Time Looking: https://gigasoft.com/wpf-chart-net-data-visualization What's New: https://gigasoft.com/proessentials9news First Walk-Through: https://gigasoft.com/wpf-chart Documentation: https://gigasoft.com/netchart/controlcomponentslibrary.htm
The package includes z.Report compiled into single binary. You gonna need also z.Report.Local which wraps it with c# API., forked from jsreport
CLI for the Elwood JSON transformation DSL — REPL, eval, and script execution.
Serpent Python literal expression serialization. Serpent provides Python ast.literal_eval() compatible object tree serialization. It serializes an object tree into bytes that can be transferred to Python and decoded there (using ast.literal_eval()). It can ofcourse also deserialize such a Python expression itself, back into the equivalent .NET datatypes. More info for the Python version is on Pypi: https://pypi.python.org/pypi/serpent
Generation backends: OpenAI images, Automatic1111, ComfyUI, a local sd-cli subprocess, streaming piper TTS, and the fal.ai queue for video (written from fal's public docs, never called against the service). The generation CONTRACTS live in Lyntai.Core — this is the backend set, kept out of the Lyntai bundle so an application that needs no media generation does not carry it.
The OUTBOUND half of Lyntai's MCP support: hosts the app's registered Lyntai ITools as an ephemeral, localhost-only HTTP MCP server so a CLI provider that runs its own agent loop can call them. Provider-neutral — a per-CLI IMcpCliDialect supplies the flags and config-file shapes (Lyntai.Providers.Default ships one for `claude`). Wired via builder.AddMcpToolHost(dialect). Runs on System.Net.HttpListener, so it needs NO ASP.NET Core.
The default Lyntai LLM backend set: the authenticated `claude` and `codex` CLIs, and any OpenAI-compatible endpoint (OpenAI/Ollama/OpenRouter/Azure) for chat + embeddings — bundled because they share one dependency footprint and ship no native payload. Media backends live in Lyntai.Generation; heavier ones (local GGUF, the MEAI bridge) are their own packages.
Local, open source CLI for AI agent skills: validate, inspect, diff, eval and package SKILL.md skills, with console, JSON or SARIF output. Nothing is sent to any service.
Send a .NET app's LLM calls to Seerlens with one line (.UseSeerlens() on any IChatClient), then diff runs, see real cost and gate CI.