ASCII Fluid Simulation

Demo: https://pras.us/fluidsim.html

Fluid Simulator made with JavaScript. Implements a simplified FLIP (Fluid-Implicit-Particle) method for incompressible fluid dynamics, visualized through ASCII characters. Key technical aspects include:

• Hybrid Eulerian-Lagrangian approach using particles and a fixed grid
• Particle-based simulation with grid transfer for pressure solving
• Pressure field solved using iterative method to enforce incompressibility
• Particle advection: dx/dt = v integrated explicitly
• Incompressibility enforced through pressure projection
• Boundary conditions: no-penetration at solid boundaries
• ASCII rendering: Density ρ mapped to character set via linear interpolation
• Interactive circular obstacle with velocity affecting nearby particles
• Fixed time step Δt for temporal discretization

The simulation offers a model of fluid behavior while balancing computational efficiency. It provides real-time interaction and ASCII-based visualization of fluids.

Algorithmic Pathfinding Visualization

Demo: https://pras.us/pathfinder.html

This interactive pathfinding visualizer implements and compares four fundamental graph traversal algorithms:

• Dijkstra's Algorithm: Employs a greedy approach with O((V + E) log V) time complexity, using a priority queue optimized for weighted graphs.
• A* Search: Enhances Dijkstra's algorithm with a heuristic function (Manhattan distance) to improve search efficiency in directed searches.
• Breadth-First Search (BFS): Utilizes a queue for level-order traversal, optimal for unweighted graphs with O(V + E) time complexity.
• Depth-First Search (DFS): Implements an iterative stack-based approach, exploring as far as possible along each branch before backtracking.

Key technical features:

• Asynchronous Visualization: Uses Promise-based delays for step-by-step algorithm visualization.
• Dynamic Obstacle Creation: Implements real-time wall placement and erasure with event listeners.
• Path Reconstruction: Utilizes path reconstruction for efficient O(n) path backtracking post-search.

The visualizer offers an interface for algorithm comparison, demonstrating the trade-offs between exploration patterns and efficiency in different graph scenarios.

ASCII Fractal Engine

C Fractal Engine which renders various fractals in ASCII to the standard output. Allows for zooming and panning.

• Fractal algorithms:
  • Mandelbrot Set: \(z_{n+1} = z_n^2 + c\), with \(z_0 = 0\)
  • Julia Set: \(z_{n+1} = z_n^2 + c\), with \(z_0 =\) pixel coordinate
  • Burning Ship: \(z_{n+1} = (|Re(z_n)| + i|Im(z_n)|)^2 + c\)
• Escape-time algorithm: Iterates until |z| > 2 or max iterations reached
• ASCII rendering: Maps iteration counts to character set via modular arithmetic
• Dynamic range adjustment: Implements zooming and panning functionality
• Cross-platform input handling: Custom getch() implementation for Linux, conio.h for Windows
• Aspect ratio correction: Ensures proper scaling on non-square terminal windows

The engine provides an interactive, terminal-based exploration of fractal geometry.

clac.RS

clac.RS is a robust stack-based programming language compiler implemented in Rust, featuring a custom lexer, parser, intermediate representation (IR) generator, and x86-64 assembly code generator. This project is currently unfinished. The source code is available on GitHub.

Key technical features implemented so far:

• Lexical Analysis and Parsing:
  • Custom tokenizer for lexical analysis
  • Handles numeric literals, operators, and language-specific keywords
  • Implements error handling for invalid tokens and syntax
• Intermediate Representation Generation:
  • Converts parsed tokens into a custom IR
  • Uses HashSet for efficient function name lookup
  • Performs semantic analysis, including function redeclaration checks
• Stack-Based Operations:
  • Arithmetic operations: +, -, *, /, %, **
  • Comparison operators: <, <=, >, >=, ==, !=
  • Stack manipulation: drop, swap, rot, pick
• Control Flow:
  • Conditional branching with 'if' and 'skip'
  • Function definitions and calls
• Code Generation:
  • Generates x86-64 assembly code from IR
  • Efficient stack-based operations in assembly
  • Handles function calls and returns
• Memory Management:
  • Stack-based memory model for efficient variable storage
  • Function-specific stack frames
• Error Handling:
  • Robust error checking during parsing and IR generation
  • Detailed error messages for syntax and semantic errors
• Build Process:
  • Integrates with NASM and LD for assembly and linking
  • Generates executable output from source code

This compiler demonstrates advanced concepts in language design, parsing techniques, and low-level code generation.

SigLangv2

SigLangv2 is an interpreter for SigLang, a custom C-like programming language with unique syntax. Implemented in Python using PLY (Python Lex-Yacc). Source Code is available on GitHub.

Key technical features:

• Lexical Analysis:
  • Handles various constant types: decimal, hexadecimal, character, float, and string
  • Implements complex regular expressions for token matching
• Symbol Table Management:
  • Hierarchical symbol table structure with scoping support
  • Efficient symbol lookup with recursive search through scopes
  • Handles function parameters and array dimensions
• Intermediate Representation (IR):
  • Generates custom IR for further processing and optimization
  • Supports various operations: arithmetic, logical, control flow
• Type Checking:
  • Implements type checking for arithmetic and logical operations
  • Ensures type consistency in assignments and function calls
• Control Flow Handling:
  • Supports if-else statements, for loops, and while loops
  • Implements break and continue statements
• Function Management:
  • Handles function definitions and calls
  • Implements parameter passing and return value checking
• Error Handling:
  • Provides detailed error messages for syntax and semantic errors
  • Implements error recovery mechanisms for parsing
• Code Generation:
  • Generates intermediate code for execution
  • Supports various operations and control structures

CSG 3D

CSG 3D is a 3D First-Person Shooter game implemented in Python using only 2D graphics libraries. This project won 1st place in the CMU 15-112 Term Project Showcase.

Key technical features:

• 3D Rendering Engine:
  • Custom raycasting algorithm for 3D world rendering
  • Efficient depth calculation and wall projection
  • Dynamic lighting system with torch and weapon effects
• Game World Management:
  • Procedural map generation with predefined and random layouts
  • Collision detection for player and enemy movement
  • Mini-map rendering for navigation
• Enemy AI and Pathfinding:
  • Multiple enemy types with unique behaviors and abilities
  • Line-of-sight checking for enemy rendering and attacks
  • Basic pathfinding for enemy movement towards the player
• Weapon System:
  • Implement shooting mechanics with hit detection
  • Ammunition management and reloading system
  • Visual effects for weapon firing and impacts
• Sprite and Animation Handling:
  • Custom sprite loading and management system
  • Frame-based animations for enemies, weapons, and effects
  • Dynamic sprite scaling based on distance for pseudo-3D effect
• Game State Management:
  • Wave-based gameplay with increasing difficulty
  • Score tracking and health management
  • Menu system with play and replay options
• Performance Optimizations:
  • Efficient rendering techniques to maintain smooth framerates
  • Object pooling for projectiles and effects
  • View culling to render only visible elements

CSG 3D showcases advanced game development techniques and computer graphics concepts, creating a compelling 3D experience using 2D tools.

MRI Brain Tumor Detection

Neuroimaging with Python and Keras. Repo can be found here.

Project Details:

• Design:
  • Developed a sophisticated convolutional neural network (CNN) using Python, TensorFlow, and Keras
  • Engineered a robust architecture incorporating strategic dropout and optimized loss functions
  • Achieved exceptional tumor detection accuracy of 97.3%, surpassing conventional methods
• Model Evaluation:
  • Rigorously tested the model's performance on an extensive dataset of over 1,500 MRI scans
  • Demonstrated significant improvements over baseline models in tumor identification
• Technical Proficiency:
  • Showcased expertise in Python programming and deep learning frameworks
  • Applied advanced optimization techniques to enhance model accuracy and efficiency

Fake News Detection

An Natural Language Processing (NLP) model designed to identify and classify fake news articles with high accuracy. Repo can be found here.

Project Highlights:

• Natural Language Processing:
  • Implemented sophisticated text preprocessing techniques including tokenization, stemming, and stop word removal
  • Utilized NLTK (Natural Language Toolkit) for advanced linguistic analysis
  • Applied CountVectorizer for efficient text-to-numeric feature conversion
• Machine Learning Model:
  • Developed a Logistic Regression classifier for binary classification of news articles
  • Achieved an impressive 95% accuracy in distinguishing fake news from genuine articles
  • Implemented model persistence using joblib for easy deployment and reuse
• Data Handling and Preprocessing:
  • Processed and merged large datasets of fake and true news articles
  • Conducted thorough data cleaning and feature engineering to optimize model input
  • Employed pandas and numpy for efficient data manipulation and analysis
• Model Evaluation:
  • Utilized train-test split for robust model validation
  • Implemented confusion matrix and classification report for comprehensive performance analysis

3D Graphing Calculator

A versatile web-based graphing calculator capable of visualizing mathematical functions in both 2D and 3D space, leveraging modern web technologies.

Demo: https://pras.us/graph.html

Project Highlights:

• Mathematical Function Handling:
  • Utilized math.js library for parsing and evaluating complex mathematical expressions
  • Supports a wide range of mathematical operations, including algebraic and trigonometric functions
  • Implements dynamic function evaluation for real-time graph updates
• Interactive Visualization:
  • Implemented seamless switching between 2D line plots and 3D surface plots
  • Supports simultaneous plotting of multiple equations for comparative analysis
• User Interface Design:
  • Developed an intuitive interface for equation input and management
  • Implemented dynamic addition and removal of equation inputs
  • Designed a responsive layout for optimal viewing across various devices
• Graph Customization:
  • Allows users to adjust graph boundaries and scales
  • Implements automatic axis scaling based on function behavior
  • Provides options for customizing graph appearance and legend
• Error Handling and User Experience:
  • Implemented robust error handling for invalid mathematical expressions
  • Provided real-time feedback on equation validity and graph rendering status
  • Optimized graph updates for smooth user interaction

This project demonstrates proficiency in JavaScript, mathematical function handling, and data visualization.

RevOS: x86 Operating System

A from-scratch 64-bit operating system kernel designed for x86 architecture. Source code can be found here.

Project Highlights:

• Kernel Architecture:
  • Engineered a robust 64-bit kernel leveraging Rust's memory safety features
  • Implemented a modular microkernel design for enhanced stability and security
  • Utilized advanced x86 Assembly for critical low-level operations
• Memory Management:
  • Developed a sophisticated virtual memory system with paging support
  • Implemented efficient memory allocation algorithms for kernel and user space
  • Designed a novel approach to handle memory fragmentation and optimization
• Interrupt Handling:
  • Created a comprehensive Interrupt Descriptor Table (IDT) for managing hardware and software interrupts
  • Implemented advanced exception handling mechanisms for system stability
  • Designed an efficient context switching algorithm for multitasking capabilities
• Hardware Abstraction:
  • Developed device drivers for essential hardware components
  • Implemented ACPI support for advanced power management
  • Created a flexible hardware abstraction layer for portability across different x86 platforms
• Theoretical Foundation:
  • Based on an extensive 18-page analysis of operating system principles and design patterns
  • Incorporated cutting-edge OS research concepts into the kernel design
  • Explored innovative approaches to traditional OS challenges
• Development Environment:
  • Utilized QEMU for efficient testing and debugging of the kernel
  • Implemented a comprehensive test suite for kernel functionality verification
  • Employed Git for version control and collaborative development potential

PCC

A compiler implementation for a custom programming language, demonstrating advanced concepts in compiler design and language processing. Source code can be found here.

Key Technical Features:

• Lexical Analysis:
  • Custom tokenizer capable of recognizing various token types including keywords, identifiers, operators, and literals
  • Efficient string and numeric literal processing
• Syntactic Analysis (Parsing):
  • Recursive descent parser implementing a context-free grammar
  • Abstract Syntax Tree (AST) generation for representing program structure
  • Support for complex expressions, control structures, and variable declarations
• Semantic Analysis:
  • Symbol table implementation for managing variable scopes and types
  • Type checking and inference for expressions and assignments
  • Scope management for block-structured code
• Intermediate Code Generation:
  • Translation of AST into an intermediate representation
  • Support for arithmetic operations, control flow, and function calls
  • Optimization techniques for efficient code generation
• Code Generation:
  • Generation of x86 assembly code from the intermediate representation
  • Implementation of system calls and standard library functions
  • Efficient register allocation and memory management
• Advanced Language Features:
  • Support for conditional statements (if-else)
  • Implementation of looping constructs (while loops)
  • Basic I/O operations with 'write' functionality