FelidaeAI-native direction

AI-native logic programming language

Build software where facts, logic and execution share the same model.

Felidae is a working functional logic language for .fx files, with a native C++ interpreter, fact/query runtime, native modules, AST diagnostics and editor tooling. Higher-level agent abstractions remain an evolving research direction.

Get Started View on GitHub

Public source.fxNative C++ runtimeInteger parser

“AI-native” describes the engineering direction. This page deliberately separates current compiler/runtime capabilities from agent, memory, policy and tool-orchestration research.

Felidae

hello.fx

Person(name: "Alice", role: "Engineer")
Person(name: "Bob", role: "Manager")

main() =>
    return lambda(Person, p => p.role == "Engineer")

Source.fx

TokensIDs

ParserInteger

RuntimeAST

Real language, current syntax

Start with code, not a concept mock-up.

The old landing page treated executable examples as design sketches. The current repository has a real parser/runtime and a v2 reference corpus, so the product page now uses current newline-terminated .fx syntax and links back to its source basis.

Completed

Query structured facts directly

Current v2 syntax uses newline-terminated statements. Facts and methods live in the same .fx source model.

Current .fx syntax. New landing-page examples follow the v2 newline-terminated grammar rather than the legacy dot-terminated examples directory.

README language shape

example.fx

Person(name: "Alice", role: "Engineer")
Person(name: "Bob", role: "Manager")

main() =>
    return lambda(Person, p => p.role == "Engineer")

Programming model

Code and data share the same shape.

Felidae treats named facts as structured program data. Methods and explicit queries operate directly on that model, which is useful when software benefits from keeping knowledge and transformations close together. It is not a claim that Felidae replaces external databases in general.

Common layered application

Application code

ORM / repository

Database / SQL

Transformation layer

Application result

Felidae fact-centric path

Named facts

Felidae methods / rules

Explicit queries

Transformations

Structured result

The narrower value proposition: Felidae gives programs a lightweight fact/query model when structured knowledge, explicit transformations and inspectable logic matter more than hiding those relationships behind framework glue.

Why Felidae?

A facts-first runtime with visible boundaries.

These are implementation-backed capabilities or, where noted, source-backed capabilities still moving through build integration.

Completed

Facts as executable data

Named facts are program data, not a separate ORM-shaped representation. The runtime can query, filter and transform them directly.

Completed

Explicit logic and dataflow

Methods, immutable := bindings, conditions, lambdas, queries and returns keep data movement visible in the program.

Completed

Native C++ runtime

The current native build produces the Felidae interpreter and debugger from a C++17 CMake graph with SentencePiece-backed parsing.

Completed

Language-aware diagnostics

felidae_debug performs AST analysis, emits structured diagnostics and exposes a JSON-RPC LSP surface for editor integrations.

In Progress

Visual analysis with Celidae

Celidae has dedicated C++ visualization and analytics source with nine structural/analytical views; its current top-level native build wiring is still being reconciled with the new CMake parser graph.

Runtime and analysis

One language. Separate developer tools.

Felidae keeps execution, AST diagnostics and visualization as distinct responsibilities. That separation matters: the debugger does not execute programs, and Celidae analysis should not be confused with runtime behavior.

Implemented

Felidae

felidae

SentencePiece IDs → IntegerParser → AST → Interpreter

The primary runtime. It loads .fx programs, executes main, runs external fact queries and provides a REPL and runtime metrics.

Implemented

Felidae Debugger

felidae_debug

SentencePiece IDs → IntegerParser → AST Analyzer

A separate diagnostic target for structured checks, symbol/operator metadata and JSON-RPC editor diagnostics. It does not execute queries.

In Progress

Celidae

celidae

Shared source parser → Visualization + analysis

A separate C++ visualization/analysis codebase that turns declarations and literal fact values into self-contained interactive HTML views.

The Celidae source and acceptance suite exist, but the current top-level CMake graph does not expose a Celidae executable target. The page therefore presents it as in development rather than a guaranteed build artifact.

Celidae

Understand what your program declares — and what its facts say.

Celidae’s C++ source defines four structural views and five analytical views. It builds self-contained interactive HTML and deliberately avoids executing main, methods, queries or native libraries. The current site labels the tool in development because its top-level CMake target wiring lags the new parser build graph.

Nine implemented view types in source

Structural view

Schema

Build integration in progress

Fact types, fields and inferred field shapes.

Illustrative UI only. It represents the implemented view category and does not invent analytical results. Celidae itself generates self-contained interactive HTML from the program being inspected.

Developer tooling

Built for developers, not just language research.

The repository contains richer VS Code and IntelliJ integrations plus a growing set of lightweight editor modes and a Tree-sitter grammar scaffold.

Completed

VS Code

Syntax highlighting, snippets, import navigation, hovers, CodeLens actions, debugger integration and felidae_debug-backed Problems diagnostics are implemented in the repository extension.

Completed

IntelliJ IDEA

The JetBrains plugin registers .fx files, highlights syntax, uses felidae_debug --check-json and provides run/check/visualize actions.

Completed

Language server

felidae_debug exposes a JSON-RPC LSP mode over stdio plus symbol, library, builtin and operator metadata surfaces.

In Progress

Tree-sitter

A dedicated tree-sitter-felidae grammar scaffold exists for editor/navigation work; it is not yet upstream GitHub Linguist support.

In Progress

Lightweight editors

Repository integrations exist for Emacs, Vim/Neovim, Nano, Notepad++, Sublime Text and Zed, with capability depth varying by editor.

VS Code source IntelliJ source Tree-sitter source

Native modules

Keep the language expressive. Keep host-facing work native.

Felidae’s CMake graph builds native shared-library modules for capabilities that do not belong inside the core interpreter. Typed .fx declarations remain the language-facing contract.

Native ABI docs Browse modules

Felidae

core/*.fx

NativeRuntime

C++ module

Host capability

Data formats

CSV and other structured-data boundaries can live behind typed module calls.

Data access

The native build graph includes database, set, group, fact and fact-analysis modules.

Networking

HTTP is implemented as a native shared-library target.

Process / host

Process/platform access is exposed through a native module boundary.

Analysis / graphics

WordNet, plotting and GTK/Qt targets are present in the native CMake graph.

Use cases

What can you build with Felidae?

The strongest use cases follow directly from what the runtime and repository already implement. AI-native software is shown separately as a research direction, not as a completed agent platform.

Completed

Knowledge applications

Why it fits: Domain knowledge often gets duplicated across records, query layers and application code.
Felidae approach: Represent knowledge as named facts and keep the transformations that use it in Felidae methods and queries.
Value: A compact model where stored knowledge and the logic that operates on it stay inspectable together.

In Progress

Fact-oriented analysis

Why it fits: Small analytical workflows can accumulate database, scripting and visualization glue before the analysis itself begins.
Felidae approach: Use facts and arrays as the working data model, with runtime/native modules for computation and Celidae source for visual analysis.
Value: Data declarations, transformations and analysis intent remain close to one another.

Completed

Native-backed utilities

Why it fits: Interpreted languages still need efficient access to files, processes, data formats, networking and platform libraries.
Felidae approach: Keep typed contracts in .fx and move host-facing or performance-sensitive work behind the native module ABI.
Value: The core language stays small while native capabilities remain explicit at module boundaries.

In Progress

Developer tooling

Why it fits: A language is difficult to adopt when every editor implements its own partial understanding of the grammar.
Felidae approach: Use felidae_debug metadata and diagnostics as a shared source for richer integrations, with Tree-sitter and lightweight modes for additional editors.
Value: Editors can share runtime-aware diagnostics instead of each inventing a separate semantic model.

Completed

Research and experimentation

Why it fits: Reasoning experiments need visible data, explicit rules and a way to inspect how structures relate.
Felidae approach: Use typed facts, inheritance, queries, custom operators and explicit methods to encode experiments as executable programs.
Value: Experiments remain deterministic source artifacts rather than hidden notebook state.

Research

AI-native software

Why it fits: AI applications often scatter knowledge, tools, memory and policy across framework-specific glue.
Felidae approach: Felidae is being explored as a language-level foundation for making more of those concepts explicit and inspectable.
Value: A research direction toward auditable intelligent software without claiming finished autonomous-agent semantics today.

AI-native direction

Where Felidae is going.

Xnovity is evolving Felidae toward intelligent software that can represent knowledge, reasoning, tools, policies and execution more explicitly. The key credibility rule is simple: current runtime features stay separate from research abstractions.

Available today

typed/named facts
explicit methods and immutable bindings
queries and fact indexing
custom operator metadata and mixfix parsing
native module boundary
AST diagnostics and LSP
editor integrations
Celidae visualization/analytics source

Evolving research

agent-oriented language abstractions
richer AI workflow semantics
long-lived memory models for intelligent software
language-level tool orchestration
policy and approval abstractions
higher-level reasoning and semantic AI libraries

Research syntax such as hypothetical agent/memory/policy blocks is intentionally absent from the primary code path until it is supported by the current parser/runtime.

Try Felidae

Go from source file to execution with the current native build.

The commands below follow the current native build wrappers and runtime CLI. They use v2_examples rather than the legacy dot-terminated examples directory.

Linux / macOS

Build

./build.sh

Run

./build/felidae v2_examples/selective_fact_query.fx

Query

./build/felidae v2_examples/selective_fact_query.fx '? Candidate(region: "north", id: Id)'

Inspect

./build/felidae_debug v2_examples/selective_fact_query.fx --check-json

Windows

Build

.\build.cmd

Run

build\felidae.exe v2_examples\selective_fact_query.fx

Query

build\felidae.exe v2_examples\selective_fact_query.fx '? Candidate(region: "north", id: Id)'

Inspect

build\felidae_debug.exe v2_examples\selective_fact_query.fx --check-json

Clone from GitHub Browse v2 examples Read build notes

Platform status

Native first while the parser migration settles.

The current build wrappers support the native CMake graph. Older documentation lists broader cross targets, but the newest wrappers explicitly reject non-native targets until proper SentencePiece-aware CMake toolchains or presets exist.

Completed

Linux

Native CMake build through ./build.sh.

Completed

Windows

Native CMake build through build.cmd/build.ps1.

In Progress

macOS

The native shell/CMake path is intended to be portable to AppleClang/macOS, but this redesign did not verify a current macOS artifact.

In Progress

Cross targets / Android

The current build wrappers reject non-native targets and require a dedicated CMake toolchain or preset.

In Progress

WASM

Older repository documentation describes WASM tooling, but the current build wrappers reject non-native targets during the SentencePiece/CMake migration.

Public source

Explore the implementation.

The active Felidae repository exposes the runtime, current v2 examples, native modules, debugger, Celidae source, tests, quality scripts and editor integrations. The page links directly to those artifacts instead of asking developers to trust marketing copy.

View Felidae on GitHub Documentation Examples

src/Runtime + parser

v2_examples/Current syntax

native_modules/C++ modules

tests/Regression tests

scripts/Quality tooling

*-extension/Editor tooling

Licensing note: the repository is public, but a root project license was not visible in the reviewed repository state. This redesign therefore says “public source” rather than making a stronger legal open-source claim. Adding a project LICENSE should be a repository follow-up before OSI promotion.

Project status

Transparency is a feature.

The page now separates what the current native build demonstrably provides, what is still being integrated, and what remains research. This is not an apology; it lets technical visitors understand the project quickly.

Implemented

native felidae interpreter target
SentencePiece token model and IntegerParser
AST and direct interpreter runtime
fact query/index runtime
native module ABI and shared-library targets
felidae_debug diagnostics and LSP
VS Code and IntelliJ source integrations
regression/quality tooling

In development

Celidae build integration with the current top-level CMake graph
Tree-sitter/editor ecosystem expansion
cross-target CMake toolchains and WASM path
packaging, releases and distribution polish

Research

agent-oriented language abstractions
richer AI workflow semantics
long-lived memory models for intelligent software
language-level tool orchestration
policy and approval abstractions
higher-level reasoning and semantic AI libraries

Architecture

Follow the current parser path.

The architecture diagram has been updated from the older lexer story to the current SentencePiece/integer-parser implementation. Analysis products branch after parsing rather than being presented as modes of the interpreter.

Felidae .fx source

SentencePiece IDs + offsets

generated grammar/token IDs

IntegerParser

AST

Interpreter

execution + queries

felidae_debug

AST diagnostics + LSP

Celidae source

visualization + analysis

Interpreter native boundary

Native C++ modules

selected host-facing capabilities

A different programming model

Not a universal replacement for established languages.

Felidae is most interesting when the program benefits from explicit structured knowledge and logic. The comparison below describes architectural tendencies, not a scorecard against Python, Rust, C++ or TypeScript.

Common application tendency

Felidae approach

Common tendencyData model separated across application and persistence layers

FelidaeFacts and program logic can coexist in .fx

Common tendencyQueries hidden behind ORM/repository abstractions

FelidaeExplicit fact queries and indexed runtime access

Common tendencyTransformations distributed across service layers

FelidaeNamed methods, immutable bindings and visible dataflow

Common tendencyEditor diagnostics built independently per integration

Felidaefelidae_debug provides a shared semantic/diagnostic surface

Common tendencyAI orchestration mostly framework glue

FelidaeResearch direction toward more language-native intelligent-software concepts

Quick answers

Technical questions, direct answers.

What is Felidae?

Felidae is a functional logic programming language for .fx files. Its current runtime is a native C++ interpreter built around a SentencePiece-backed integer parser, AST execution, fact/query runtime and native-module boundary.

Is Felidae only an AI-agent research proposal?

No. The interpreter, parser, runtime, debugger/LSP, native modules, current v2 examples and editor integrations are implementation-backed. Agent-oriented abstractions and richer AI workflow concepts are still research directions.

Why does the page say AI-native?

It describes the direction in which the language is being developed: intelligent software with explicit knowledge, reasoning and tool boundaries. It is not a claim that a production-ready autonomous-agent DSL exists today.

Does current Felidae use the old lexer pipeline?

The newest native build uses SentencePiece-backed integer token entries and IntegerParser. Older README wording and some legacy examples still reference the earlier lexer/dot-terminated grammar and should not be used as the current landing-page model.

What syntax should new examples use?

Use v2_examples as the current reference: statements are newline-terminated, while examples/ contains older dot-terminated programs.

What is felidae_debug?

It is a separate C++ AST-analysis target. It emits structured diagnostics, supports JSON-RPC LSP mode and exposes symbols, builtins, libraries and operator metadata for editor integrations.

What is Celidae?

Celidae is a separate visualization and analysis codebase. It parses declarations and literal fact values into self-contained interactive HTML views and deliberately does not execute main, queries or native libraries.

Can I build Celidae from the current top-level CMake graph?

The Celidae source and acceptance tests are present, but the current top-level CMake file does not define a celidae target. Until that wiring is restored, this site labels Celidae build integration as in progress.

Met Felidae at Open Source India?

You scanned the card. Now inspect the language.

Start with current v2 examples, follow the native runtime, inspect the debugger/LSP source, and open an issue if you find a gap. Felidae is early in its journey and the useful contribution right now is technical scrutiny.

GitHub Report an issue Documentation

Felidae is developed by Xnovity Software Pvt. Ltd.

Language notes Native ABI v2 examples