Projects Portfolio

Back to Resume

Projects Portfolio

Technical Profile

As a versatile software engineer I’ve built a diverse portfolio of personal projects focusing on developer tools, language implementation, and high-performance systems. My work demonstrates particular strength in creating efficient, user-friendly tools that solve real-world development challenges.

Technical Skills Demonstrated

Languages & Frameworks

  • Rust: Systems programming with advanced patterns:
    • Async programming with tokio and futures
    • Thread management with mpsc channels and oneshot
    • Error handling with anyhow and Result propagation
    • Command-line interfaces with clap
    • Clean architecture with module separation
    • Language Server Protocol implementation
    • Parser development with tree-sitter integration
  • Python: Developer tooling and language processing:
    • Integration with system APIs and libraries
    • Performance optimization for data processing
    • Concurrent processing with asyncio and threading
    • API design and implementation
    • Full-text search and indexing implementation
  • JavaScript/C++: Language tooling and parser development:
    • C++ scanner implementation for complex lexical analysis
    • External scanner API integration for advanced parsing features
    • Tree-sitter grammar development in JavaScript
    • DSL implementation for language parsing
  • C#/Unity: Performance-oriented developer tooling:
    • Advanced scene automation with intelligent analysis and processing
    • DOTS/ECS architecture with automated GameObject-to-Entity conversion pipelines
    • Performance optimization with Job system and Burst compilation
    • Meticulous IL instruction/code path analysis for optimal SIMD utilization
    • Unity editor tool development with intuitive UI/UX design
    • Diagnostic engine frameworks with automated issue detection and resolution
    • Scene streaming optimization with subscene management

Performance Engineering

  • Parallel processing and multi-threading optimization
  • Memory management and allocation strategies
  • Data structure optimization for minimal overhead
  • Cache-aware algorithms and data layout
  • CPU/GPU bottleneck identification and resolution
  • Profiling and performance metrics analysis

Developer Tools Engineering

  • Command-line interface design with user experience focus
  • Language server implementation and parsing techniques
  • Incremental parser development for code analysis
  • Cross-platform tool development and distribution
  • Configuration management for flexible deployment
  • Automated testing and verification systems

Software Architecture

  • Modular design with clear separation of concerns
  • Performance-oriented system design
  • Data-oriented design principles
  • Scalable architecture patterns for large codebases
  • Component-based design with well-defined interfaces
  • Asynchronous processing patterns
  • Plugin-based systems for extensibility
  • Cross-platform compatibility considerations

AI/ML Integration

  • Vector embeddings for semantic search and retrieval
  • Computer vision and object detection models
  • Speech recognition and processing

Vectorizer (Rust)

Text Embedding Generator and Vector Database Integration

  • Built a high-performance text embedding tool in Rust that processes project files for AI retrieval
  • Implemented integration with Qdrant vector database for storage and retrieval of embeddings
  • Created a configuration system supporting both global and per-project settings
  • Developed Neovim integration for automatic embedding of saved files
  • Used the All-MiniLm-L(6/12)-V2 models for generating high-quality text embeddings

Technical Highlights:

  • Implemented async processing with Tokio and thread management for optimal performance
  • Designed a robust CLI with clap that follows modern design patterns similar to Ruff and uv
  • Used mpsc channels and oneshot patterns for efficient inter-thread communication
  • Implemented sophisticated error handling with anyhow and custom error propagation
  • Created command-line progress indicators with automatic refresh for better UX

Cyber Language Server (Rust)

LSP Implementation for the Cyber Language

  • Developed a full Language Server Protocol implementation in Rust
  • Created advanced language features including completions, diagnostics, and hover information
  • Implemented document parsing and syntax validation
  • Built with an extensible architecture for future language features

Technical Highlights:

  • Used tower-lsp for async LSP communication with high performance
  • Leveraged tree-sitter for incremental parsing and efficient syntax analysis
  • Implemented concurrent document processing with Tokio and DashMap
  • Designed thorough error handling with anyhow and custom error types
  • Built with tracing for comprehensive logging and diagnostics

Tree-Sitter-Cyber (Rust/C++/JavaScript)

Custom Parser for the Cyber Language

  • Developed a complete Tree-sitter grammar for the Cyber scripting language
  • Created syntax highlighting queries for advanced code visualization
  • Implemented complex parsing rules to handle the language’s unique syntax
  • Built support for editor integration across multiple platforms
  • Implemented a custom C++ scanner for handling complex language features

Technical Highlights:

  • Created precise grammar definitions in JavaScript using Tree-sitter’s DSL
  • Implemented custom precedence rules for complex expression parsing
  • Generated optimized Rust parser code from Tree-sitter grammar
  • Developed custom highlighting queries for semantic tokens
  • Built cross-platform compatibility with WASM compilation support
  • Custom C++ Scanner Implementation:
    • Created a sophisticated lexer using Tree-sitter’s external scanner API
    • Implemented proper indentation-based scoping with indent/dedent token generation
    • Developed robust string literal handling for single, double, and triple quotes
    • Built support for multiline strings with appropriate delimiter tracking
    • Implemented a delimiter stack system for proper nesting and context tracking
    • Added debug facilities for development and troubleshooting
    • Utilized modern C++ features for memory safety and performance

ProStream (Unity/C# WIP Asset)

Advanced Unity Developer Tool for Scene Conversion and Streaming

  • Created a comprehensive developer tool that automates the conversion of traditional GameObject scenes to DOTS entity subscenes
  • Developed a rule-based engine that intelligently analyzes scene structures and automatically creates optimized streaming layers
  • Designed an intuitive editor interface that simplifies the complex process of setting up scene streaming with minimal manual configuration
  • Built an automated system that handles GameObject-to-Entity conversion, subscene creation, and streaming setup through a guided workflow
  • Implemented extensive documentation with step-by-step guides to help developers integrate advanced streaming capabilities into their projects

Technical Highlights:

  • Scene Automation & Processing:

    • Created an intelligent scene analysis system that identifies optimal streaming boundaries based on object density and relationships
    • Built automatic layer generation that organizes GameObjects into logical streaming groups based on customizable rule sets
    • Implemented a GameObject-to-Entity conversion pipeline with automatic hierarchy preservation and reference maintenance
    • Developed a subscene creation system that handles all the complexity of breaking apart monolithic scenes into efficient streaming units

  • Performance Optimization Tools:

    • Designed automated frustum culling integration using Unity’s job system with Burst compilation for scenes processed by the tool
    • Created a configurable terrain LOD generation system that developers can customize based on their performance requirements
    • Implemented performance metrics tracking with Unity’s ProfilerRecorder API to help developers optimize their converted scenes
    • Built bounds checking and occlusion systems that are automatically configured during the conversion process