Reinforcement learning typically involves an agent interacting with an environment to achieve a maximum reward. Our project disregards the traditional approach of estimating policies and simplifies Reinforcement Learning to a sequence modeling problem that can effectively be solved by the Trans- former architecture. Our project extends the capabilities of the initial Decision Transformer (DT) [4] to learn from mixed- quality input data. Our modified Decision Transformer quantifies the benefit of return-conditioned imitation learning on mixed- quality data by leveraging the robomimic datasets. We show that our Decision Transformer significantly outperforms standard behavioral cloning on mixed-quality data for the Lift and Can tasks. Overall, our Decision Transformer and semi-sparse reward function provide a new way to tackle the challenges of imitation learning with mixed-quality data.

In this work, we explore a data-driven learning- based approach to learning the kinodynamic model of a small autonomous vehicle, and observe the effect it has on motion planning, specifically autonomous drifting. When executing a motion plan in the real world, there are numerous causes for error, and what is planned is often not what is executed on the actual car. Learning a kinodynamic planner based off of inertial measurements and executed commands can help us learn the world state. In our case, we look towards the realm of drifting; it is a complex maneuver that requires a smooth enough surface, high enough speed, and a drastic change in velocity. We attempt to learn the kinodynamic model for these drifting maneuvers, and attempt to tighten the slip of the car. Our approach is able to learn a kinodynamic model for high-speed circular navigation, and is able to avoid obstacles on an autonomous drift at high speed by correcting an executed curvature for loose drifts. We seek to adjust our kinodynamic model for success in tighter drifts in future work.

https://arxiv.org/abs/2402.14928

The user-space API presented in this project aims to simplify the process of utilizing multiple GPUs as a single, powerful computing resource. By abstracting the complexities associated with multi-GPU programming and CUDA, this API allows developers to leverage the benefits of parallel computing without the need for extensive knowledge in these areas: https://arxiv.org/abs/2504.01266

This is a sophisticated tool that transforms satellite visualization into a field-accurate operational modeling platform. This comprehensive simulation incorporates multiple high-fidelity components including RF occlusion detection, regulatory compliance enforcement, realistic antenna patterns, mechanical slewing behaviors, dynamic beam visualization, and detailed link status monitoring. By implementing industry-standard specifications, real-world data integration, and accurate physics models, the platform enables precise scenario testing for satellite communication networks under authentic operational conditions. The system's modular architecture allows engineers to evaluate complex satellite-to-ground interactions, assess regulatory compliance, optimize network performance, and visualize RF characteristics in a single integrated environment - effectively bridging the gap between basic satellite visualization and production-ready network engineering. 

https://omeedcs.github.io/starlink-satellite-simulator/

It missed its landing - math is hard LOL 😭

The return trajectory system uses a bunch of core physics and math to make the flight feel real. I calculate the direction from the booster to Mechazilla with vector math - stuff like directionToTarget.subVectors(landingTarget, position).normalize() to get a clean unit vector pointing the right way. Then, I figure out pitch and yaw using Math.atan2() to rotate the booster so the engines aim toward the target.

To make the rotation look smooth (not all jerky), I use linear interpolation (which I learned in computer graphics, trust me im not a genius lmao ): lerp(currentAngle, targetAngle, rate * deltaTime). For movement, it’s basic kinematics: update position and velocity each frame using Newton’s laws. Thrust is applied in whatever direction the booster’s facing using quaternions and vector transforms. I also simulate gravity and drag based on altitude, so it reacts realistically.

There’s a phase-based system that controls the different parts of the flight, and during final landing, I use a PID controller to fine-tune everything - constantly adjusting to keep the booster on target. It’s basically my CURRENT best attempt at faking what real rocket guidance systems do at SpaceX.

https://omeedcs.github.io/starship-simulator/

RemoteSyncFS is a super basic distributed file system implementation using FUSE (Filesystem in Userspace) that provides transparent access to remote files. It automatically synchronizes file contents between local and remote machines, giving users the illusion of working with local files while keeping the content synchronized across systems.

https://github.com/omeedcs/RemoteSyncFS

essentially a collection of custom user-space memory pagers for ELF binaries on Linux systems. i implement different memory paging strategies for loading and executing ELF binaries. includes: 

 APager (Basic ELF loader that maps segments into memory)

DPager: Demand paging implementation with SIGSEGV handling for lazy loading

HPager: Hybrid paging approach

https://github.com/omeedcs/MemPharos

This is inspired by End of Track!

Stratego Spheres is a two-player turn-based strategy game implemented in Python. Each player controls five pieces and one ball, with the objective of moving their ball to the opponent's goal line. The game combines elements of chess and soccer, requiring both tactical positioning and strategic planning.

Implements adversarial search algorithms and advanced heuristic evaluation techniques to create sophisticated AI agents that compete in a zero-sum strategic environment with perfect information.

https://github.com/omeedcs/StrategoSpheres

i had no clue what a ray tracer was before i took honors graphics. 

its essentially a C++ ray tracer with all the core functions, the key optimization is a Bounding Volume Hierarchy (BVH) acceleration structure that organizes scene objects in a binary tree of bounding boxes, allowing the system to quickly eliminate large portions of the scene from intersection testing-reducing computational complexity from O(n) to O(log n) and achieving a 30% performance improvement. The implementation handles multiple material properties (diffuse, specular, reflective, transparent), supports anti-aliasing through supersampling, and includes additional features like stereogram generation, making it a comprehensive physically-based rendering system suitable for generating high-quality 3D images.

https://github.com/omeedcs/RayTracer

essentially built a WebGL-based 3D mannequin control system using quaternions for smooth rotational movement and spatial positioning

i love quaternions, i genuinely think they are one of the coolest parts of computer graphics. 

i essentially learned that linear Interpolation works really well when you are dealing with two points in 3D space in which the space between them is flat, aka. We are in flat euclidean space. but it doesnt work well for something like a satellite. you have to do something like SLERP. 

 In this project we explore developing a state-based SuperTuxKart hockey player. SuperTuxKart is essentially a version of mario kart, lol. 

https://www.omeedtehrani.com/research-papers/state-based-dagger-agent-for-supertuxkart-using-dnns

we are a podcasting group focused on giving voices to great people at the intersection of engineering, research and startups - we hope to inspire the next generation of computer scientists and open thinkers. founded by me and laith altarabishi. :D

https://www.youtube.com/@fspodofficial

A  blog simply documenting my path to (hopefully greatness) as i learn

https://blog.omeedtehrani.com/