Open-source alternatives to Db Tutorial

LiteDB is a serverless, embedded NoSQL document database for .NET applications. It persists data into a single portable file, functioning as a BSON data store that resides within the application process rather than running as a separate server. The system is ACID compliant, utilizing write-ahead logging to ensure atomic, consistent, isolated, and durable transactions. It includes built-in encryption to provide secure local data storage and protect files on disk from unauthorized access. The project covers object-document mapping to convert classes into document formats, indexed search capabi

This is an in-memory B-Tree data structure implementation for Go. It provides a memory-resident collection that maintains sorted elements to enable efficient retrieval, modification, and the management of sorted key-value maps. The project supports ordered mutable collections and sorted key-value stores, allowing for fast lookups, insertions, and deletions while preserving the sort order of keys. It provides capabilities for range searching within sorted memory structures and maintains the organization of datasets through self-balancing node splitting and recursive binary search.

LiteDB is a serverless NoSQL document store and embedded database engine for .NET applications. It persists unstructured documents and binary data into a single standalone disk file, allowing the database to run within the application process rather than as a separate server. The system supports strongly typed queries through Language Integrated Query and allows the execution of standard SQL commands for data retrieval and transformation. It provides native mapping of plain classes into document formats and secures stored information via symmetric-key file encryption. The engine includes cap

bbolt is an ACID-compliant embedded key-value store for Go applications. It persists all data in a single memory-mapped file on disk, organizing information using B+ trees to facilitate sorted key iteration and efficient range queries. The project distinguishes itself through a hierarchical data organization model, allowing buckets to be nested within other buckets to create a tree-like structure. It employs a single-writer, multi-reader locking mechanism and copy-on-write transactions to ensure serializable isolation and data integrity. The system includes comprehensive data management capa

Shumway is a browser-based Flash emulation system designed to execute Shockwave Flash content without the need for native plugins. It focuses on the preservation of legacy Flash content by rendering SWF files within modern web browsers. The project utilizes a JavaScript-based virtual machine to parse and execute SWF bytecode, recreating the original program logic. This environment simulates a CPU and memory layout to enable the display and playback of interactive animations and applications. The system manages a software-based rendering pipeline that draws vector shapes and bitmaps onto a ca

Grist is a relational spreadsheet platform that combines the flexibility of a spreadsheet with the power of a relational database. At its core, it manages structured data across multiple linked tables, using a relational database engine to organize information while providing a familiar grid interface. The platform supports Python-based formulas for complex calculations and data transformations, with automatic recalculation when referenced cells change. The system is designed for self-hosted deployment, storing data in either portable SQLite files or enterprise-grade PostgreSQL databases. It

Vyper is a security-focused, typed programming language and compiler designed for creating smart contracts that execute on the Ethereum Virtual Machine. It utilizes a Pythonic syntax to define contract logic and state, serving as a target for formal verification to allow for machine-checked proofs of correctness. The language distinguishes itself through strict architectural constraints that prioritize predictability and security. It enforces acyclic call graphs by prohibiting recursion and mandates bounded loops to ensure static gas prediction. Additionally, it features a native fixed-point

TIC-80 is a fantasy console platform and multi-language game engine that provides a virtual retro game development environment. It operates via a bytecode virtual machine that executes game logic within fixed memory and resolution constraints. The project distinguishes itself by offering integrated asset editors for pixel art, tile maps, and a pattern-based chiptune audio workstation all within a single environment. It supports multi-language scripting, allowing developers to write logic in Lua, JavaScript, or Ruby, and provides a standalone game exporter to package projects into native execu

Luau is a high-performance programming language evolved from Lua 5.1. It consists of a bytecode virtual machine, an embeddable scripting engine, and a static code analyzer designed to provide a secure, sandboxed execution environment for host applications. The project is distinguished by its gradual typing system, which combines automatic type inference with optional manual annotations to detect bugs without requiring full static typing. It also features native vector mathematics for high-performance operations and a specialized debugging system that uses bytecode patching to minimize executi

Frege is a purely functional programming language that compiles to JVM bytecode, providing Haskell-like semantics for the Java platform. It is built around a Haskell-inspired compiler that implements non-strict evaluation and a static type inference system to ensure data immutability and prevent side effects. The project distinguishes itself through a sophisticated type system featuring rank polymorphism, type-class based dispatch, and static purity enforcement. It includes a JVM language bridge and a foreign function interface that map Java classes and interfaces into functional types, allow

Janino is a lightweight Java compiler and scripting engine designed to transform source code into executable bytecode directly within the application heap. It functions as a runtime compiler and class loading library, enabling the dynamic definition and execution of Java classes, methods, and expressions without requiring a full application restart. The project distinguishes itself through its ability to perform in-memory compilation and recursive descent parsing, which allows for the resolution of complex dependencies and circular references during the translation process. It provides a fram

Dolt is a relational database engine that integrates version control directly into the database management layer. It functions as a version-controlled SQL database that tracks every row and schema change using a commit-based history, allowing users to branch, merge, and audit data modifications. By implementing a wire-protocol-compatible server, the system enables standard SQL clients and tools to interact with versioned data as if they were connecting to a traditional relational database. The platform distinguishes itself by applying repository-style workflows to data management, including s

Trilium is a local-first personal knowledge management system designed to store and organize information on a user's own device. It functions as a hierarchical knowledge base where every note acts as both a standalone document and a container for nested children, allowing for complex information relationships and deep categorization. The platform distinguishes itself through a component-based interface that dynamically renders diverse content types, including rich text, diagrams, and executable scripts. All data is persisted within a single relational database file, which supports a versioned

Actual is a local-first personal finance manager designed to help users track income, manage expenses, and maintain a balanced budget. It functions as a data-centric application that prioritizes offline access and local file storage, ensuring that financial records remain available and performant regardless of network connectivity. The platform distinguishes itself through a robust architectural foundation that emphasizes data integrity and auditability. Every financial action is recorded as an immutable sequence of events, and all currency values are processed using an integer-based arithmet

H2 is a JDBC-compliant relational database management system written in Java. It functions as an embeddable SQL database that can run directly within an application process to remove network latency, or as an in-memory database for high-performance volatile storage. It also includes a web-based console for executing SQL commands and administering schemas. The system is characterized by its flexible deployment modes, including a standalone server mode for remote TCP/IP access and a mixed mode for simultaneous local and remote connectivity. It features a dialect emulation layer and compatibilit

Expr is a high-performance expression evaluation engine and language for Go applications. It functions as a dynamic rule engine that parses and executes custom logic and data validations at runtime without requiring the application to be recompiled. The system utilizes a sandboxed logic executor to run expressions without side effects. It ensures program termination by employing instruction-level loop detection to prevent infinite loops and isolates the evaluation process from the host system. The engine employs a bytecode-based virtual machine and abstract syntax tree analysis to achieve ex

HVM2 is a high-performance execution environment for pure functional programs, implemented as a systems-level runtime in Rust. It functions as a massively parallel functional runtime that uses interaction combinators to achieve automatic parallelism across multi-core CPUs and GPUs. The project distinguishes itself by using a graph-rewriting computational model to execute programs via local reduction rules, which eliminates the need for manual locks or atomic operations. It employs beta-optimal reduction and lazy evaluation to optimize higher-order functions and eliminate redundant computation

This project is a comprehensive technical interview question bank and reference library designed for software engineering roles at major technology companies. It serves as a study guide and knowledge base covering the core principles of high-performance systems programming and computer science theory. The collection focuses on deep technical domains, including C++ language mastery, distributed systems design, and database engineering. It provides detailed material on consensus protocols, cluster coordination, and the architectural differences between SQL and NoSQL implementations. The resour

Tengo is a dynamic, embeddable scripting language for Go applications that allows for the execution of custom scripts without requiring the host binary to be recompiled. It operates as a bytecode-compiled virtual machine, transforming source code into a compact intermediate representation for execution on a stack-based engine. The system is designed as a secure scripting sandbox, enforcing strict limits on memory allocation and execution time to safely run untrusted code. It supports concurrent script execution by cloning compiled bytecode and using recursive immutability conversion to share

CircuitPython is a specialized derivative of the MicroPython runtime designed as an embedded Python interpreter for microcontrollers. It provides a high-level language environment that allows for direct hardware access through a dedicated hardware abstraction layer and a Python microcontroller runtime. The project is distinguished by firmware that exposes the microcontroller as a native USB mass storage device. This allows users to edit code directly on the device as if it were a removable drive, eliminating the need for specialized flashing tools and enabling filesystem-triggered code reload

Expr is a statically typed expression engine and domain-specific language for parsing and evaluating dynamic logic strings within Go applications. It functions as a bytecode expression evaluator that executes compiled logic with guaranteed termination and memory safety. The engine utilizes a specialized compiler and virtual machine to achieve high-performance execution. It employs static type validation during the compilation phase to ensure operand compatibility and prevent runtime crashes. The project provides a data transformation engine capable of mapping, filtering, and aggregating coll

This project provides a server-side language runtime and a standardized Docker image for deploying applications across different operating systems. It functions as an execution environment for generating dynamic HTML, JSON, and XML content, while also serving as a command line interface for automation scripts and background jobs. The runtime is designed for extensibility through a C-based extension architecture, allowing the loading of custom modules for specialized functionality. It supports multiple server application interfaces, including a FastCGI web interface for high-performance commun

Cinder is a high-performance Python runtime implementation based on CPython. It is designed as an execution environment optimized for large-scale distributed systems and cloud environments. The project integrates a distributed memory cache and an asynchronous memory layer to manage data across multiple network nodes. It also provides a native C extension framework for developing high-performance compiled modules that link directly into the interpreter memory space. The system covers capabilities for asynchronous data retrieval, large-scale execution, and the integration of embedded scripting

Hy is a Lisp implementation for Python that allows for writing Lisp syntax which compiles to Python bytecode. It operates as a Python-based Lisp dialect and S-expression language, providing full access to the Python standard library and ecosystem. The language focuses on macro-based metaprogramming, featuring an AST-walking macro system and reader macros that allow for custom syntax transformations and parsing rules. It enables the manipulation of the abstract syntax tree to extend language capabilities. The project includes a read-eval-print loop for interactive development and supports sta

Bigcache is a thread-safe, in-memory key-value store for Go designed to minimize garbage collection pauses. It functions as a memory-optimized cache capable of storing gigabytes of data while maintaining low latency during high-volume operations. The system avoids garbage collection overhead by managing memory through large byte arrays and manual allocation. It utilizes a circular-buffer layout to reuse space and lock-striped sharding to reduce contention during concurrent read and write access. The project provides capabilities for high-volume in-memory caching and low-latency data retrieva

mQuickjs is a compact JavaScript engine designed for memory-constrained devices, such as microcontrollers, requiring as little as 10 KB of RAM and 100 KB of ROM. It achieves this through a fixed-buffer memory allocation scheme that avoids system heap usage, a compacting tracing garbage collector that eliminates fragmentation, and a ROM-embedded standard library that reduces both memory footprint and startup time. The engine compiles JavaScript source into portable bytecode that can be stored in persistent memory and executed without reparsing, and it emulates IEEE 754 floating-point arithmetic

rawdrawandroid is a framework for building Android applications using C and Make. It provides a native development system that compiles source code into standalone executable packages, bypassing the standard Java or Kotlin toolchains and virtual machines. The project features a native UI toolkit for creating hardware-accelerated graphics windows and a dedicated hardware interface for direct communication with USB peripherals and onboard sensors. It utilizes a containerized build environment to ensure consistent compilation and signing of binaries without requiring local toolchain installation