DEV Community: Devesh Bhushan

Building a 3D Exoplanet Simulator with Real-Time Habitability Analysis

Devesh Bhushan — Wed, 25 Jun 2025 05:15:56 +0000

Have you ever wondered what it would be like to engineer alien worlds? That's exactly what ExoCosmos lets you do. Inspired by NASA's Eyes on Exoplanets project, we wanted to go beyond just visualizing distant planets - we wanted to let users actively modify their properties and explore how small changes could make them more Earth-like and potentially habitable.

Our project is currently live on: Internet

You should check it out!

What ExoCosmos Does

ExoCosmos is an interactive web-based simulator that combines real exoplanet data with 3D visualization and scientific modeling. Users can select from a collection of real exoplanets discovered by astronomers, view them in detailed 3D models, and then become "planet engineers" by adjusting four key properties through sliders: planetary mass, planetary radius, star mass, and distance from the star.

As users modify these parameters, the system calculates the Earth Similarity Index (ESI) in real-time, providing immediate feedback on how Earth-like their modified planet becomes. Each planet also comes with educational content including fascinating facts and explanations of why certain conditions make life more or less likely

The Technical Challenge

We faced some technical challenges along the way like implementing volumetric clouds,level of detail system and many others like:

Advanced Visual Effects

We implemented several sophisticated rendering techniques:

Fresnel effects for realistic light reflection at glancing angles
Ray marching to simulate light passing through volumes like clouds
Procedural cloud generation using seed-based algorithms instead of pre-made images
Volumetric clouds with layered depth and natural movement
Noise techniques like Worley Noise and Fractal Brownian Motion for surface and atmospheric detail

Level of Detail System

One of our biggest technical achievements was creating a dynamic Level of Detail (LoD) system. As users zoom in on a planet, the clouds gradually fade away to reveal the detailed surface below, just like you'd see from a real spacecraft.
This required careful optimization of shader computations and managing rendering layers to balance visual quality with performance

Texture Mapping

We applied various maps to give planets a rich, lifelike feel:

Displacement maps for surface elevation
Normal maps for detailed surface texture
Ambient occlusion maps for realistic shadowing
Diffuse maps for color and material properties

The Science Behind the Interface

Making ExoCosmos scientifically accurate required extensive research into how scientists measure planetary habitability. We studied multiple metrics including ESI, RSI, BSI, PHI, and SEPHI.

After comparing various approaches, we chose an enhanced version of the Earth Similarity Index because it strikes the right balance between scientific accuracy and user-friendliness. The ESI is calculated from four key values: radius, density, escape velocity, and surface temperature, producing a score between 0 and 1 where Earth itself scores.

Real-Time Calculations

The challenge was condensing complex habitability models into something interactive. We created a system where four user-friendly sliders control six core factors behind the scenes. When users adjust the sliders, our system instantly calculates the ESI score and reflects changes in the 3D model in real-time.

This required careful state management to keep slider values, ESI calculations, and 3D model transformations perfectly synchronized while maintaining smooth performance without unnecessary re-renders.

Frontend Architecture

The web interface was built using Next.js with TailwindCSS for styling, emphasizing both performance and modern design, We created:

A dynamic landing page explaining ExoCosmos' purpose
An interactive planet catalog for browsing and selecting exoplanets
Dedicated exploration pages where 3D planets are rendered alongside detailed information

We used component libraries like Aceternity UI and shadcn/ui to give the website a polished, modern feel while writing modular, reusable code for future scalability.

Major Challenges We Overcame

Performance Optimization

Rendering complex 3D planetary scenes with volumetric clouds, dynamic lighting, and real-time updates pushed our limits. We had to carefully optimize shader computations, manage rendering layers, and implement our LoD system to maintain smooth performance across different devices and browsers

State Management Complexity

Ensuring real-time updates between UI interactions and the 3D scene required sophisticated state management. We needed to keep all slider values, ESI calculations, and 3D model transformations in perfect sync while maintaining smoothness and avoiding unnecessary re-renders

Scientific Accuracy vs Usability

The most intellectually challenging aspect was translating complex habitability models into something user-friendly. Many scientific models involved multi-variable mathematics that were either too abstract or computationally heavy for real-time interaction. We had to find the sweet spot between scientific rigor and user experience.

What We Learned

This project was an incredible learning experience across multiple domains:

3D Web Development- We gained hands-on experience with Three.js, learning to build, animate, and texture realistic 3D environments. We dove deep into shader programming, lighting models, and optimization techniques for web-based 3D graphics
Space Science- We expanded our understanding of exoplanets and the factors that impact habitability. Learning about the Earth Similarity Index and other habitability metrics gave us new appreciation for the complexity of determining whether distant worlds could support life
User Experience Design- We learned how to make complex scientific concepts accessible through intuitive interfaces. The challenge of translating multi-dimensional scientific data into simple, interactive controls taught us valuable lessons about user-centered design.
Performance Engineering- Managing real-time 3D rendering while maintaining smooth interactions across different devices taught us about optimization strategies, from shader efficiency to state management patterns.

Future Directions

Expanded Dataset: We plan to integrate more real exoplanets using NASA's extensive databases, giving users access to a much wider universe of worlds to explore.
Advanced Metrics: Beyond ESI, we want to incorporate other habitability indices like SEPHI for more comprehensive analysis.
Educational Features: We're developing classroom-oriented features including guided tutorials, challenges, and assessment tools to make ExoCosmos a powerful educational resource.
Data Visualization: Interactive charts and graphs that change in real-time as users adjust parameters would provide deeper insights into how modifications affect habitability

Conclusion

ExoCosmos was a great learning experience for me I would like ot thanks my friends Ayush R. Nair, Debashish Nayak, Arjit Saxena without there help this project might not be completed.

Building an AI Sales Agent: From Voice to Pitch.

Devesh Bhushan — Sat, 18 Jan 2025 08:58:36 +0000

The Story Behind It

When I signed up for EnCode 2025, The problem presented to me is to make an agent which is capable of delivering high-quality, natural-sounding voice interactions and should feel like talking to a real person with super low latency.
So,
I built a system that can handle complete sales conversations for online coaching centers - from greeting potential customers to understanding their needs and pitching relevant courses. All of that in a very postive tone human like speech. Think of it as your tireless sales agent that never has a bad day!

Technical Stack

Speech Processing: Whisper Large V3 Turbo for crystal-clear understanding.
Brain Power: LLaMA 3.3 70B for intelligent conversations.
Voice Output: F5 TTS for natural-sounding responses.
Memory: Pinecone vector database for context and information retrieval.
Demo Platform: Google Colab

How It All Works

In a simple flow it goes through 3 main system

Speech to Text (STT)
Large Language Model (LLM)
Text to Speech (TTS)

So,

User->STT->LLM->TTS->User

In detail:

Customer speaks → Whisper transcribes.
Stage Manager (using regex) tracks conversation phase.
Pinecone fetches multiple data from databases.
LLaMA 3.3 70B crafts the perfect response.
F5 TTS brings it to life with natural speech.

Features

Smart Voice Selection: 6 different AI voices (2 male, 4 female)
Context-Aware Responses: Thanks to vector similarity search
Structured Conversation Flow: Managed by a dedicated Stage Manager

Current Limitations

Demo runs on Colab.
Memory constraints with 8k token limit.
Heavy on computational resources.
API dependency for core functions.
Latency is quite high.

What I Learned

Technical Insights

Use of Vector Databases: Working with Pinecone showed me how vector DBs can be game-changers when having limited context window. The ability to perform similarity searches on conversation history and training materials in milliseconds is very powerful.
Stage Management Matters: When given the stage in which the conversation is currently in, it becomes so easy to incorporate examples related to the stage like examples on how to give a pitch what kind of questinos to ask etc.
Web Integration: The most critical part of all of this is to be able to pass data between frontend and backend effectively using fastapi. By using Webhooks, we were able to pass data back and forth while initialising the AI for call at a single time only and keeping the connection open for the whole conversation.

System Design Lessons

Chunking is Crucial: Processing audio in 5-second chunks rather than waiting for complete utterances significantly improved the user experience by allowing to reduce the time in processing.It's all about finding that sweet spot between accuracy and speed.
Modular Architecture Wins: Breaking the system into distinct services (STT, LLM, TTS) made development and debugging so much easier. When something went wrong, I could quickly pinpoint which part needed fixing.

Real-World Constraints

API Economics: Managing multiple API calls (Whisper, LLaMA) taught me the importance of optimizing API usage. Trying to use minimum number of API calls and still being fast is very challenging.
Reducing Latency: Reducing Latency is very hard when you are constently fetching and processing data from internet. In Future I will try to minimize the number of times one has to upload or download the data from internet.

Unexpected Challenges

Prompt Engineering: Prompt Engineering is very crucial and can decide whether your model is going to be as coherent as a human or is going to repeat the same sentence over and over again.
Context Window Limitations: The 8k token limit forced me to be creative with context management. Not storing the whole information but to get only the relevant chunks of it from vector database allowed me to design a data structure for LLM which have all the necessary info the LLM needs, to respond.

What's Next?

Using Multithreading to reduce latency.
Adding Multi-lingual Support.
Adding more bots type like 'Lead Bot' which call the customer to close the deal after intial lead.

Try It Yourself

colab.research.google.com

GitHub

If you have some Suggestions regarding the system please ask them in comments.