Open-source alternatives to Nodebestpractices

This project provides a comprehensive architectural framework and set of standardized patterns for building, securing, and scaling production-ready Node.js applications. It serves as a foundational guide for establishing consistent development workflows, operational observability, and reliable service integration across distributed software systems. The framework distinguishes itself by emphasizing a schema-first approach to API development, ensuring that interface definitions drive the creation of server stubs, client libraries, and type definitions. It promotes a cloud-native posture by int

vite-plus is a unified web development toolchain and command line interface designed to manage Vite builds, JavaScript runtimes, and package managers from a single entry point. It functions as a JavaScript runtime manager for installing and pinning language versions, a monorepo task orchestrator for dependency-aware script execution, and a project scaffolding engine for bootstrapping applications and libraries. The project distinguishes itself by consolidating a full development lifecycle into one tool, featuring a unified static analysis engine that performs type-checking, linting, and forma

Agent-skills is a collection of structured instructions and behavioral personas designed to standardize how AI coding agents perform engineering tasks. It functions as a workflow orchestrator that maps natural language intent to repeatable technical sequences and verification checklists. The project distinguishes itself through the use of specialized markdown-defined roles, such as security auditors or test engineers, to apply targeted domain expertise. It employs an evidence-based verification model that requires runtime data or passing tests as mandatory exit criteria to ensure AI-generated

This project is a comprehensive technical interview preparation resource and computer science interview guide. It serves as an educational reference for developers to study core software engineering fundamentals and common coding patterns required for employment screenings. The repository provides detailed guides and references covering data structures and algorithms, networking and security, operating systems, and web development. It specifically focuses on the implementation and complexity analysis of sorting, searching, and graph algorithms. The material encompasses a wide breadth of comp

This project is a Swift iOS architecture template that implements the Clean Architecture pattern. It organizes software into distinct layers to decouple business rules from external frameworks, user interfaces, and infrastructure to improve testability and maintenance. The template incorporates Domain Driven Design to isolate core business logic and utilizes a modular application structure to divide features into independent modules. It employs the Coordinator pattern to remove routing logic from view controllers and a dependency injection framework to ensure components remain independent and

This project is a collection of reference implementations demonstrating recommended patterns for organizing code and managing data flow in Android applications. It provides structural examples of layered architecture, separating code into presentation, domain, and data layers to decouple business logic from data sources. The repository includes specific samples for implementing declarative user interfaces that automatically update their visual state based on underlying data changes. It further demonstrates how to manage object lifetimes and component dependencies to reduce boilerplate and sim

Bun is a high-performance runtime environment designed to execute JavaScript and TypeScript applications with minimal latency and high throughput. Built on a native core implemented in Zig, it provides a unified execution engine that leverages JavaScriptCore for efficient memory management and low-latency startup. The project functions as an all-in-one toolchain, integrating a native bundler, transpiler, package manager, and test runner into a single command-line interface. What distinguishes Bun is its focus on native system integration and developer productivity. It features a high-performa

js-the-right-way is a JavaScript best practices guide and coding standards reference designed to provide a curated collection of industry materials for writing maintainable code. It serves as a web development education resource, offering organized documentation on modern JavaScript patterns and idioms. The project is structured as a markdown-based documentation site, where guides written in lightweight markup are rendered as static pages. It utilizes a curated network of hyperlinks to connect internal documentation with external industry standards.

QFramework is a Unity game architecture framework designed to separate presentation, system, and data logic. It implements a layered software architecture to manage complex game states and provides a game engine utility library to reduce boilerplate code. The framework is centered on the Command Query Responsibility Segregation pattern, which separates data modification commands from data retrieval queries. It utilizes a dependency injection container to manage the lifecycles and resolution of singletons and modular components, alongside an event-driven system for state synchronization to pre

This project is a reference implementation for structuring Java applications using clean architecture and domain-driven design principles. It provides a template for organizing code into concentric layers, ensuring that core business rules and domain entities remain entirely independent of external frameworks, databases, and delivery mechanisms. The architecture relies on the dependency inversion principle to decouple business logic from infrastructure. By defining abstract interfaces for data access and external services, the system allows for the replacement of underlying technologies witho

OpenCat-Quadruped-Robot is a development framework and motion control API for building four-legged robots. It provides a comprehensive environment for quadruped robot development, featuring tools for locomotion gait design, inverse kinematics, and a layered control architecture that separates high-level intelligence from low-level motion. The project distinguishes itself as an embedded AI deployment tool, allowing users to train, quantize, and deploy machine learning models to vision modules for tasks such as object detection and visual target tracking. It further supports complex human-robot

This project is an ASP.NET Core solution template and boilerplate that implements a clean architecture pattern for building enterprise applications and web API backends. It provides a standardized project scaffold designed to separate business logic from infrastructure and user interfaces to ensure high testability and low coupling. The project features a database agnostic structure that allows for switching persistence providers without altering core business logic. It includes a command line tool for enterprise application bootstrapping, enabling the automated generation of project structur

This project is a comprehensive library of reference implementations and patterns for building web applications using the Go Fiber framework. It provides curated templates and implementation guides for creating REST APIs, web servers, and structured backend services. The repository serves as a practical resource for applying architectural patterns, including Clean and Hexagonal architectures, as well as port-and-adapter decoupling. It offers detailed examples for integrating common web features such as OAuth2 authentication, JWT verification, WebSockets for real-time communication, and server

KotlinMvp is a short-video Android application developed with Kotlin. It utilizes the Model-View-Presenter architectural pattern to maintain a clear separation between business logic and the user interface. The project integrates a short-video playback interface that supports content discovery through category filtering and popularity rankings. It employs a Retrofit REST client for network communication and the RxJava reactive framework to manage asynchronous data streams and background tasks. Image loading and caching are handled via the Glide image loader. The application includes capabili

ThinkJS is a server-side web framework designed for building applications on the Node.js runtime. It serves as a development platform that supports TypeScript and the latest ECMAScript standards to create stable and maintainable backend services. The framework employs a layered application architecture that separates concerns into controller, service, and model tiers. It utilizes a dependency-injected service model to manage singleton services and a middleware-based system for request handling and route dispatching. Development is supported by a build pipeline that transpiles modern JavaScri

This project is a reference implementation of a production-ready backend API built with Rust and the Actix-Web framework. It serves as a codebase demonstrating the development of a newsletter subscription service, encompassing the management of subscriber sign-ups, email confirmations, and campaign delivery. The project highlights a layered architecture that separates concerns into handler, service, and repository layers. It utilizes an actor-based concurrency model for handling HTTP requests and employs trait-based abstractions to decouple business logic from external dependencies, such as e

EquinoxProject is an ASP.NET 9 web application template and reference implementation for building enterprise software. It provides a structural boilerplate centered on clean architecture, domain-driven design, and the separation of read and write operations through a command query responsibility segregation framework. The project incorporates event sourcing to track the history of business entities as a sequence of events for auditing and state reconstruction. It utilizes a layered approach to decouple business logic from external dependencies and frameworks. The system includes capabilities

COLA is a core architectural toolkit for Java applications designed around domain-driven design and a clean, object-oriented layered architecture. It provides a framework for managing project structures, implementing domain-driven entity modeling, and organizing enterprise application architecture to decouple business logic from technical dependencies. The project features a pluggable logic extension system that allows for the addition of new functionality through defined extension points without modifying the core codebase. It also includes a project bootstrapping toolkit and an integration

Util is a comprehensive development framework for .NET designed to implement layered architectures and domain driven design. It provides a toolkit of base classes and tools for building full stack applications, specifically focusing on the creation of backend admin frameworks and management interfaces. The project distinguishes itself through a boilerplate generator that produces the necessary types and classes to standardize repetitive architectural patterns. It also includes a micro-frontend orchestrator that enables the splitting of large frontend modules into independent projects for sepa

This project is a reference implementation of the Model-View-ViewModel pattern using Android Jetpack components. It serves as an architecture template and layering guide, dividing application code into view, domain, and data layers to ensure a unidirectional flow of dependencies. The implementation focuses on state management and configuration change handling. It demonstrates how to synchronize UI updates across multiple screens using shared state containers and preserves application state during transitions between portrait and landscape orientations. The codebase covers a broad surface of

NorthwindTraders is an ASP.NET Core sample web application that demonstrates the implementation of business logic and request handling. It is structured as a layered architecture web app, decoupling core application rules from the user interface and data access layers. The project utilizes Entity Framework Core for its database implementation, employing a code-first relational database approach. This allows the database schema to be generated and evolved automatically from C# entity models via an object-relational mapper. The application manages relational data and serves web requests throug

NorthwindTraders is an ASP.NET Core sample application that serves as a reference implementation for developing RESTful web APIs. It demonstrates the use of the .NET ecosystem to expose business functionality over HTTP. The project provides an example of a layered application architecture, separating business logic from infrastructure and external dependencies. It implements an Entity Framework Core data layer using a code-first approach to map application objects to a relational database. The implementation covers core backend capabilities including relational database integration, server-s

koa2-note is a project focused on Koa2 web server development and Node.js asynchronous programming. It provides a framework for building web servers and APIs using an asynchronous middleware pipeline to handle request and response cycles. The project emphasizes a layered backend architecture that decouples routing, business services, and data models. It distinguishes itself through the integration of relational databases for persisting user sessions and application data, alongside a build process that includes JSX-to-JavaScript compilation for frontend assets. The capability surface covers b

This project is a reference implementation of the Model-View-Presenter architecture for Android applications. It serves as a structural example of how to separate business logic from the user interface through a presenter-based framework. The implementation focuses on a clean architecture approach, using presenters to mediate all communication between the data model and the view. It employs a passive view pattern and interface-based decoupling to isolate the user interface from domain rules. The architecture incorporates interactor-based domain logic and layered separation to reduce systemic

This is a demonstration and template project that applies Clean Architecture principles to SwiftUI application development. It implements a layered architecture that separates presentation, business logic, and data access into independent layers, with unidirectional data flow managed through a single immutable app store that serves as the sole source of truth for all screens. The project distinguishes itself through its implementation of interactor-driven business logic, where all domain rules and workflows live in stateless objects that receive requests and update the central store. Dependen

This project is an architectural design course and educational resource focused on breaking large JavaScript codebases into independent, testable, and environment-agnostic components. It serves as a modular programming guide and reference for implementing structural strategies and best practices in production environments. The material emphasizes the use of design patterns to create decoupled components and robust logic. It specifically covers strategies for dependency inversion and the use of generic interfaces to ensure logic can run across different JavaScript runtimes. The guide provides

This project is a collection of software engineering principles and architectural design patterns designed to minimize the mental effort required to understand and maintain source code. It serves as a guide for implementing clean code methodologies and architectural simplification to reduce the overall cognitive load on developers. The framework emphasizes aligning module boundaries and ubiquitous language with business stakeholders to prevent architectural ripple effects. It advocates for balancing service granularity to avoid the overhead of distributed monoliths and suggests favoring objec