#rust (133)
- How GPUI Works: Deep Dive into Internals
Deep technical explanation of how GPUI works under the hood - architecture, internals, compilation, and real-world examples.
- Building High-Performance UIs with GPUI: A Guide for Rust Developers
Embark on a comprehensive journey to master GPUI, Zed's GPU-accelerated UI framework for Rust, from basic setup to advanced application development on macOS and Linux.
- Building Kanbots: AI Agents, Git Worktrees, and Desktop Automation
Build Kanbots, a desktop Kanban app orchestrating AI agents on cards using Git worktrees for isolated tasks. Learn multi-persona development workflows with Tauri and Svelte.
- Setting Up Your GPUI Development Environment
Learn to set up your GPUI development environment, understand its core concepts, and build a basic 'Hello World' application for macOS or Linux.
- Building UI with Views and Elements: The Core of GPUI
Dive into GPUI's core UI building blocks: Views and Elements. Learn how to construct interactive user interfaces using GPUI's hybrid rendering model, state management, and styling capabilities.
- Your First GPUI Application: Windows and the Application Lifecycle
Dive into GPUI by setting up your development environment and building your first GPU-accelerated application, focusing on the core application lifecycle and window management in Rust.
- Managing Application State: Entity, Context, and Global
Explore GPUI's core state management patterns: Entity, Context, and global state. Learn to build interactive, data-driven UI components with practical Rust examples.
- Styling Your GPUI Application: Layout and Appearance
Explore GPUI's code-driven styling for layout and appearance. Learn to use flexbox, colors, and borders to create visually appealing GPU-accelerated user interfaces in Rust.
- Handle User Input in GPUI with Actions and Event Handling
Readers will learn to define, dispatch, and handle custom actions, enabling them to build interactive user interfaces in GPUI applications.
- Advanced UI Patterns and Custom Components
Dive into advanced GPUI concepts to build complex, reusable UI components with custom rendering, state management, and asynchronous interactions. Learn from Zed's source.
- Project: Building a Simple Task List Manager
Build a simple task list manager using GPUI, learning to manage state, handle user input, and render dynamic lists in a GPU-accelerated environment.
- Building Responsive GPUI Apps with Async Executor
Learn to use GPUI's asynchronous executor for building responsive applications, safely performing non-blocking operations and updating the user interface.
- Integrating Platform Services and Basic Testing Strategies
Learn how to integrate platform-specific services like clipboard and file dialogs in GPUI and establish basic testing strategies for your applications.
- Mastering GPUI: A Deep Dive Guide
Dive deep into GPUI, Zed's UI framework, from environment setup to building complex AI chat agents. Learn core concepts, unstable APIs, and best practices directly from source.
- Optimize and Debug GPUI Apps for Responsive UIs
Optimize GPUI applications by debugging performance issues, understanding hybrid rendering, and applying best practices for responsive user interfaces.
- Project: Building an AI Chat Agent User Interface
Build a responsive AI chat agent UI with GPUI, focusing on dynamic view updates, asynchronous operations, and effective state management for complex conversational flows.
- Setting Up Your Kanbots Workshop: Tauri v2 and Svelte 5
Kickstart your Kanbots project by setting up the foundational Tauri v2 desktop framework with a Svelte 5 frontend, creating a robust environment for AI-powered workflows.
- Integrate AI Agents in Kanbots to Automate Code Generation
Learn to integrate AI agents into Kanbots, enabling them to generate code and perform tasks within isolated git worktrees directly from Kanban cards.
- Mastering Git Worktrees for Isolated Agent Tasks
Learn how to leverage Git worktrees within Kanbots to provide isolated development environments for AI agents, enabling parallel and conflict-free task execution.
- Orchestrating Multi-Agent Workflows with Personas
Learn to orchestrate multi-agent AI workflows in Kanbots, assigning distinct personas for tasks like code generation and review using Git worktrees.
- Real-time Agent Progress and User Control UI
Equip Kanbots with real-time AI agent progress, logging, and user controls like pause, resume, and cancel, enhancing user interaction with multi-agent workflows.
- Securing API Keys and Robust Error Handling
Learn how to secure sensitive AI API keys and implement robust error handling in your Kanbots desktop application for a production-ready experience.
- Logging Agent Activities and Deployment Considerations
Implement robust logging for AI agent activities within Kanbots and understand the crucial steps for packaging and deploying your cross-platform desktop application.
- NVIDIA CUDA-Oxide 0.1: Experimental Rust-to-CUDA Compiler Released
NVIDIA CUDA-Oxide 0.1 released. Enables writing SIMT GPU kernels in safe, idiomatic Rust. Direct compilation of standard Rust code to CUDA. Upgrade urgency: optional.
- Introduction to Edge AI Agents and Environment Setup
Understand the landscape of on-device AI agents and tiny LLM systems, set up your development environment, and explore core tooling for edge AI.
- Stoolap Practical Field Guide
Embark on a comprehensive journey to master Stoolap, a modern embedded SQL database, from the ground up, with practical steps and engaging challenges for developers and data engineers.
- Rust Practical Field Guide
Embark on a comprehensive journey to master Rust from the ground up, with practical steps and engaging challenges for modern, production-ready applications.
- Accelerating Queries with Parallel Execution
Discover how Stoolap leverages parallel execution to significantly accelerate complex SQL queries, enhancing performance for both transactional and analytical workloads in embedded applications.
- How Stoolap Uses MVCC for Concurrent Data Operations
Learn how Stoolap leverages Multi-Version Concurrency Control to manage simultaneous transactions, ensuring consistent data and high performance.
- Understanding Stoolap's Cost-Based Query Optimizer
Learn how Stoolap's cost-based query optimizer intelligently plans queries, interpret EXPLAIN output, and design schemas to achieve optimal database performance.
- Build a Hybrid OLTP/OLAP Analytics Dashboard with Stoolap
Readers will learn to build an analytics dashboard leveraging Stoolap's HTAP features for real-time data ingestion and complex analytical queries.
- Setting Up Your Stoolap Development Environment
Get started with Stoolap by setting up your Rust development environment, adding Stoolap as a dependency, and running your first embedded SQL queries.
- Stoolap's Storage Engine and Query Pipeline Internals
Understand Stoolap's storage engine, MVCC, and query pipeline to design efficient schemas and write better queries for OLTP, OLAP, and vector search.
- Stoolap: Define, Query, and Manage Data with Basic SQL
You will understand Stoolap's relational data model and apply fundamental SQL operations to define, manipulate, and query data.
- The Stoolap Ecosystem: Future Directions and Community
Explore the Stoolap ecosystem, its community, future development roadmap, and how to contribute to this innovative embedded SQL database. Understand its ongoing evolution.
- Stoolap Production Best Practices for Performance
Learn to deploy, manage, and optimize Stoolap applications for production environments, ensuring high performance and stability in real-world scenarios.
- Welcome to Stoolap: A New Generation Embedded Database
Discover Stoolap, a modern embedded SQL database built with Rust, and learn how its unique features like MVCC, parallel execution, and vector search redefine embedded data management.
- Setting Up Your Rust Development Environment (Rust 1.94.0)
Embark on your Rust journey by setting up your development environment. Learn to install Rust 1.94.0 using rustup, understand the cargo build system, and run your first Rust program.
- Rust Variables, Data Types, Functions, and Control Flow
Readers will gain proficiency in Rust variables, data types, functions, and control flow for building dynamic and efficient programs.
- Use Cargo to Manage Rust Projects and Dependencies
Learn to initialize, build, run, test, and manage Rust projects and their dependencies using Cargo, Rust's build system and package manager.
- Effectively Use Rust Borrowing and Lifetimes for Memory Safety
Learn how Rust's borrowing and lifetimes enable safe, efficient data sharing and prevent common memory errors without a garbage collector.
- Master Rust Ownership for Memory Safety and Performance
Understand Rust's ownership model to manage memory safely and efficiently, mastering stack, heap, move, copy, and clone concepts for robust code.
- Traits: Defining Shared Behavior and Polymorphism
Master Rust traits to define shared behavior, enable polymorphism, and write flexible, extensible code. Learn trait bounds, default implementations, and dynamic dispatch with `dyn Trait`.
- Rust Structs, Enums, and Pattern Matching for Custom Data Types
Learn to define custom data types using Rust structs and enums, then apply pattern matching to interact with and control program flow effectively.
- Handle Errors in Rust with Option, Result, and the '?' Operator
Understand how to explicitly manage potential failures in Rust using Option, Result, and the '?' operator to write reliable, production-ready code.
- Collections, Iterators, and Closures for Efficient Data Processing
Understand Rust's collections like Vec and HashMap, apply iterators for efficient data processing, and utilize closures to write concise, performant code.
- Concurrency and Asynchronous Programming in Modern Rust
Explore concurrency and asynchronous programming in Rust using threads, Arc, Mutex, async/await, and the Tokio runtime for high-performance applications.
- Rust Unsafe, FFI, and Advanced Design Patterns for Interoperability
Master unsafe Rust, Foreign Function Interface, and advanced design patterns to build high-performance, interoperable applications.
- Build a Production-Ready Rust CLI: Arguments, Files, Errors
Master building production-ready Rust CLI applications by implementing argument parsing, file I/O, and robust error handling for dependable tools.
- Rust Development: Build Robust Production Applications
Develop high-performance, secure applications using Rust by understanding its unique approach to memory safety, ownership, and concurrent programming.
- Stoolap vs. SQLite: Complete Technical Comparison 2026
Comprehensive comparison of Stoolap and SQLite - features, performance, pros & cons, and when to use each for embedded database needs.
- Ratatui Practical Field Guide
Embark on a comprehensive journey to master Ratatui, the powerful Rust library for building interactive terminal user interfaces, from the ground up.
- Building MermaidLint: A Production-Grade Mermaid Analyzer & Fixer
Learn to build a strict, production-grade Mermaid code analyzer and fixer in Rust, from scratch to deployment, with compiler-level rigor.
- Build a Rust CLI: Project Setup, Environment, and Basic Arguments
Learn to set up a robust Rust CLI project, configure its environment, define structure, and implement basic command-line argument parsing with best practices.
- Building a Mermaid Parser's Abstract Syntax Tree (AST)
Build a parser module to convert Mermaid tokens into a strongly typed Abstract Syntax Tree, providing structural representation and robust syntax error reporting.
- Implement a Production-Ready Mermaid Lexer in Rust
Learn to implement a production-ready lexer in Rust that accurately tokenizes Mermaid syntax, efficiently handling whitespace, invalid characters, and precise error reports.
- Designing Rust Data Structures for a Mermaid AST
Design and implement the core Rust data structures that form a Mermaid Abstract Syntax Tree, accurately representing diagram components for analysis.
- Implement a Strict Validation Layer for Mermaid AST in Rust
Learn to build a robust validation layer for Mermaid ASTs, detecting syntax and semantic errors and generating precise Rust-style diagnostics.
- Build a Deterministic Rule Engine for Linting and Fixing Mermaid
Implement a deterministic rule engine in Rust to lint and fix Mermaid Abstract Syntax Trees, ensuring strict validation and error handling.
- Designing and Implementing a Rust CLI: UI and Output Modes
Learn to build a robust Rust CLI for a Mermaid analyzer, implementing argument parsing, multiple output modes, and clear terminal diagnostics.
- Extend Your Rust Parser for Nested Mermaid Structures & Errors
Extend your Rust parser to handle complex Mermaid syntax, including nested structures, multiline labels, escaped characters, and enhance error recovery.
- Unit, Golden, and Fuzz Testing for Rust Mermaid Tools
Master unit, golden, and fuzz testing to ensure the integrity and robustness of your Rust-based Mermaid code analysis tools.
- Harden Rust CLI Tools: Input Validation & Supply Chain Security
Learn to secure Rust CLI applications by implementing strict input validation, managing resource consumption, and ensuring supply chain integrity against various attacks.
- Optimizing Rust Mermaid Tool for Performance and Streaming
Learn to optimize a Rust Mermaid tool for high performance, low memory, and efficient streaming input, enabling it to process large diagrams quickly.
- Automate Rust CLI CI/CD with GitHub Actions and Docker
You will learn to automate Rust CLI build, test, and release processes using GitHub Actions and Docker for secure, efficient deployment.
- Monitor, Maintain & Extend a Rust Production CLI Tool
Learn to monitor, maintain, and extend a production-grade Rust CLI tool with structured logging, performance benchmarks, and CI/CD integration.
- Terminal User Interfaces: Build Your First Rust TUI Application
Understand Terminal User Interfaces, their distinctions from CLIs and GUIs, and build your first interactive terminal app using Rust and Ratatui.
- Setting Up Your First Ratatui Project
Get started with Ratatui! This chapter guides you through setting up your first Rust TUI project, adding dependencies, and displaying a basic 'Hello, TUI!' message.
- The Basic Ratatui Loop: Drawing Your First Frame
Dive into the core of Ratatui by learning how to set up the main drawing loop and render your very first text-based frame in a Rust TUI application.
- Widgets: Building Blocks of Your UI
Explore Ratatui widgets: the fundamental building blocks for creating interactive terminal user interfaces. Learn to use Block and Paragraph to structure and display content.
- Layout Management: Arranging Your Widgets
Master Ratatui's layout system to arrange widgets effectively. Learn about Directions, Constraints, and nesting layouts to build structured terminal UIs.
- Event Handling: User Input and Interaction
Learn how to make your Ratatui TUI applications interactive by handling user input and events with crossterm, including keyboard and terminal resize events.
- State Management: Making Your UI Dynamic
Learn how to manage application state in Ratatui using the Model-View-Update pattern, enabling dynamic and interactive terminal user interfaces with practical examples.
- Custom Widgets: Extending Ratatui
Dive into creating custom Ratatui widgets to build unique and highly interactive terminal user interfaces in Rust, going beyond built-in components.
- Build Responsive Ratatui TUIs with Async & Concurrency
Implement asynchronous operations and concurrency in Ratatui TUIs to create responsive interfaces for background tasks, non-blocking I/O, and inter-task communication.
- Handle Mouse Events, Resizes, and Modals in Ratatui TUIs
After this chapter, you can implement advanced event handling, including mouse and resize events, and build interactive modal dialogs for Ratatui applications.
- Styling and Theming Ratatui Terminal User Interfaces
Readers will learn to apply custom styles, colors, and text modifiers to Ratatui TUIs, creating visually appealing and user-friendly applications.
- Optimize Ratatui Performance for Complex Terminal UIs
Learn to optimize Ratatui applications by minimizing redraws, handling events efficiently, and managing state for responsive terminal UIs.
- Project: Creating a File Browser
Build a practical terminal file browser application using Ratatui, learning advanced TUI patterns like state management, directory listing, and interactive navigation.
- Project: Building a Simple Task Manager
Build a practical terminal task manager using Ratatui, applying state management, event handling, and UI rendering techniques to create an interactive TUI application.
- Project: Developing a Monitoring Dashboard
Build a practical terminal-based system monitoring dashboard using Ratatui. Learn to integrate system metrics, manage UI layouts, and handle real-time data updates.
- Error Handling and Robustness
Learn robust error handling techniques in Ratatui applications, including graceful shutdowns, custom error types, and using `anyhow` for production-grade TUIs.
- Testing Your Ratatui Applications
Master testing strategies for your Ratatui applications, including unit, integration, and snapshot testing, to build robust and reliable terminal user interfaces.
- Deployment and Distribution
Learn how to package and distribute your Ratatui applications for various platforms, including cross-compilation and release management, ensuring users can easily run your TUI.
- Structure Scalable Ratatui Applications with Elm Architecture
Learn to apply the Elm Architecture to structure scalable and maintainable Ratatui applications, effectively managing state and handling user events in Rust.
- Craft Powerful Terminal UIs in Rust with Ratatui
Elevate your skills in building robust and visually appealing terminal user interfaces with Rust, applying Ratatui from fundamental concepts to advanced techniques.
- SpaceTimeDB Practical Field Guide
Embark on a comprehensive journey to master SpaceTimeDB from the ground up, learning to build scalable real-time applications and multiplayer experiences with confidence.
- SpaceTimeDB: Core Concepts, Architecture, and Initial Setup
Learn SpaceTimeDB's core concepts, unique architecture, and how to set up your first project, understanding its distinct approach to real-time application development.
- Structuring Your Data: Schema Design, Tables, and Relations
Dive into SpaceTimeDB schema design, learning how to define tables, relations, and indexes using Rust to structure your real-time application's data effectively.
- Set Up Your First SpaceTimeDB Project and Backend Logic
You will learn to install the SpaceTimeDB CLI, set up a project, define a database schema, write reducers, and run your instance locally.
- Querying and Filtering Real-time Data in SpaceTimeDB
Readers will learn to query and filter SpaceTimeDB's shared state in real-time using client-side subscriptions and server-side logic for dynamic applications.
- SpaceTimeDB Reducers: Implement Real-Time Server Logic in Rust
Learn to implement SpaceTimeDB Reducers in Rust, defining server-side logic to manage real-time database state and ensure consistent client synchronization.
- SpaceTimeDB Consistency: Concurrency, Transactions, Determinism
Learn how SpaceTimeDB ensures data consistency using concurrency control, transactional integrity, and deterministic execution for robust real-time apps.
- SpacetimeDB: Build Scalable Decentralized Applications
Understand SpacetimeDB's foundational concepts and practical implementation to build scalable, decentralized applications with confidence.
- Building StellarGen, a Modern High-Performance Rust SSG
Build StellarGen, a high-performance Rust SSG featuring component-driven rendering, partial hydration, and incremental builds.
- Implement CLI and Configuration for Rust SSG
Learn to implement a command-line interface and robust configuration management for a Rust static site generator using `clap`, `serde`, and `toml`.
- Load Content & Parse Frontmatter in a Rust SSG
Learn to implement content loading and frontmatter parsing for a Rust Static Site Generator, extracting metadata and handling errors effectively.
- Transform Markdown to AST with `pulldown-cmark` in Rust
Learn to parse Markdown content into an Abstract Syntax Tree using the `pulldown-cmark` library in Rust, which enables advanced content processing.
- Map Content to URLs & Generate Static Output in Rust SSG
You will learn to design routing logic, map content to URLs, and implement output generation for a robust Rust static site generator.
- Optimize Rust SSG with Incremental Builds & File Watching
Implement incremental builds and a file system watcher in a Rust SSG to significantly reduce build times and enhance the development experience.
- Implement a Robust Plugin System for Your Rust SSG
Learn to design and implement a robust plugin and extension system for a Rust SSG, enabling custom content transformations and build pipeline modifications.
- Implement Internal Links, Navigation, and Table of Contents
Implement robust internal linking, global site navigation, and automatic Table of Contents to significantly enhance your static site's usability.
- Integrate Pagefind Search into a Rust Static Site Generator
Implement Pagefind client-side search in your Rust SSG by configuring the build pipeline and integrating frontend assets for enhanced content discovery.
- Build Robust Rust SSG with Error Handling, Logging & Debugging
Learn to implement robust error handling, structured logging, and effective debugging techniques to build a resilient and maintainable Rust static site generator.
- Implement CI/CD for Rust Static Site Generator Deployment
Learn to implement robust CI/CD pipelines using GitHub Actions for automated building, testing, and deploying your Rust Static Site Generator.
- Secure Your Rust SSG with XSS Prevention and CSP
Readers will learn to integrate XSS prevention, Content Security Policy, and secure deployment practices into a Rust static site generator.
- Build a Learning Platform with a Rust Static Site Generator
Learn to build a structured learning platform using a Rust static site generator, featuring hierarchical content, dynamic navigation, and flexible templating.
- Rust SSG Guide
Build a modern Rust static site generator from parsing to production-ready features.
- Rust 1.93.0: Latest Updates & News Digest
Rust 1.93.0 release highlights updates to the musl library and enhanced compiler safety features.
- Build a Secure and Efficient Rust CLI Password Generator
You will build a production-ready Rust CLI password generator, applying security principles and best practices from setup to deployment.
- Setting Up Rust and Your Project
Learn how to set up your Rust development environment and initialize a new project for building a password generator CLI application.
- Defining CLI Flags with Clap
Learn how to define CLI flags with Clap in Rust for a customizable password generator.
- Generate Passwords with Exact Length in Rust
Readers will learn to implement a password generation loop in Rust, ensuring it consistently produces secure passwords that precisely match the user-defined length.
- Refining Character Set Management
Learn how to refine character set management in a Rust password generator, ensuring security and flexibility.
- Core Password Generation Logic
Learn how to build a secure password generator using Rust, including character set management and random number generation.
- Handling Multiple Passwords
Learn how to extend a CLI tool to generate multiple passwords with customizable options.
- Logging and Debug Output
Learn how to add logging and debug output to your Rust application using the `env_logger` crate.
- Basic Unit Testing
Learn how to write basic unit tests for a password generator in Rust using Cargo Test.
- Learn Rust Programming from Beginner to Building Projects
Understand Rust's core concepts, unique features, and build real-world projects by following a structured learning path for beginners.
- Advanced Topics: Concurrency and Asynchronous Programming
Learn Rust's concurrency model and asynchronous programming with `async`/`await`.
- Control Program Flow with If, Loops, and Functions in Rust
Implement conditional logic and repetitive actions using Rust's `if` expressions, `loop`, `while`, and `for` constructs, and define reusable functions.
- Core Concepts: Ownership, Borrowing, and Lifetimes
Explains Rust's ownership, borrowing, and lifetimes concepts for memory safety without a garbage collector.
- Core Concepts: Structs, Enums, and Pattern Matching
Learn about structs, enums, and pattern matching in Rust to create expressive and type-safe code.
- Bonus Section: Further Learning and Resources
A curated list of resources to deepen your Rust knowledge and connect with the community.
- Core Concepts: Variables, Data Types, and Operators
An introduction to variables, data types, and operators in Rust, essential for beginners.
- Intermediate Topics: Error Handling with `Result` and `Option`
Learn Rust's powerful error handling mechanisms with Result and Option enums, and the ? operator for cleaner code.
- Introduction to Rust (v1.90.0)
Learn the basics of Rust, its features, and how to set up your development environment.
- Intermediate Topics: Modules, Crates, and the Cargo Ecosystem
Learn about Rust's module system, crates, and Cargo ecosystem for organizing and managing complex projects.
- Intermediate Topics: Traits and Generics
Learn about Rust's powerful features of traits and generics for writing flexible, reusable code.
- Build a Command-Line Todo Application in Rust
Build a functional command-line todo application in Rust, mastering data structures, ownership, error handling, and JSON file I/O for persistent data storage.
- Build a Simple HTTP Server in Rust with Axum and JSON APIs
Learn to build a simple HTTP server in Rust with Axum, implementing asynchronous request handling, routing, state management, and JSON API endpoints.
- Chapters for Building a Rust CLI Password Generator
All chapters covering the creation of a production-ready Rust CLI password generator.
- Learn Rust by Javascript
A detailed comparison of JavaScript and Rust, ideal for developers transitioning from one to the other.