Home Page
Blender file rendring
User dashboard
Locating device
MarketPlace
Code Execution Enviorment
VS code Extension
AI powered code editor

Resource X - Democratizing Computing Power

Inspiration

Those late nights in college when you'd have to stay back just to use the lab's GPU for training your BERT model, that frustration of staying alone , watching my project deadline approach while expensive cloud credits drain my student budget? That's exactly what happened to me. I was trying to push my AI model accuracy from 60% to something decent, but I was stuck - the lab was always full, Google Colab kept timing out, and AWS was burning through money I didn't have.

Meanwhile, I knew my friend across town had this beast of a gaming PC - RTX 4080, 64GB RAM - that just sat there most of the day collecting digital dust. That's when it hit us: what if we could connect people who need computing power with those who have it sitting idle? What if we could democratize access to high-performance computing without the corporate middlemen and inflated costs?

That frustration, that "why doesn't this exist yet?" moment - that's where Resource X was born.

What it does

Resource X is like Airbnb, but for computing power. We've built a complete peer-to-peer marketplace where:

For Renters (like my broke college self):

Browse available GPUs, CPUs, and full systems on an interactive map
Filter by price, performance, location, and task type (AI training, 3D rendering, etc.)
Write code in our web-based IDE or VS Code extension
Get AI-powered code analysis and security scanning before execution
Watch your code execute remotely with real-time resource monitoring
Pay fair, hourly rates instead of enterprise cloud pricing

For Lenders (like my friend with the gaming rig):

List your device specs and set your own hourly rates
Accept or reject requests from renters
Monitor resource usage in real-time
Earn money from hardware that would otherwise sit idle
Everything runs in isolated Docker containers for security

Special Workflows:

Blender Rendering: Upload .blend files, get them rendered on powerful remote machines
AI Training: Optimized for machine learning with pre-built environments
VS Code Integration: Code locally, execute remotely, all from your favorite IDE

How we built it

We went all-in on a modern, security-first architecture:

Frontend (React + Vite): Dark-themed, responsive UI with real-time dashboards for both renters and lenders. Interactive device marketplace with geographic mapping using Leaflet, advanced filtering, and integrated chat interface.

Backend (Node.js + Express): RESTful API with JWT authentication, MongoDB for persistence, WebSocket connections for real-time updates, and comprehensive middleware for request validation and security.

VS Code Extension (TypeScript): Native IDE integration that connects to our backend (port 5002), offering AI-powered code analysis, remote execution capabilities, workspace synchronization, and terminal integration with AI assistant.

AI Services (Python + FastAPI): Groq LLM integration for code analysis and chat, LangChain for document processing, vector databases for intelligent search, ML-based security analysis, and automated project generation.

Security Layer: AES-256-GCM encryption for code transmission, AI-powered security scanning that scores code 0-100 and rejects malicious patterns, Docker containerization for isolated execution, and comprehensive session management.

Infrastructure: Docker containers for secure execution, Cloudinary for file storage (especially for Blender workflows), real-time resource monitoring, and automated cleanup.

Challenges we ran into

Security Nightmares: Building a platform where strangers execute each other's code is basically a security engineer's worst nightmare. We had to implement multiple layers of protection:

AI-powered code analysis that can detect malicious patterns
End-to-end encryption using AES-256-GCM with proper IVs and auth tags
Docker isolation with network restrictions and resource limits
Session-based encryption keys for each code execution

Distributed Computing Complexity: Coordinating code execution across multiple devices while maintaining real-time updates was harder than we thought. We built a comprehensive session management system with encrypted code storage, execution status tracking, and resource monitoring.

VS Code Extension Architecture: Integrating with VS Code while maintaining communication with our backend services required careful API design and state management.

File Management for Blender: Handling large .blend files and assets required us to implement a Cloudinary-based workflow with streaming uploads, temporary local storage for rendering, and automatic cleanup.

Real-time Everything: Users expect instant feedback. We implemented WebSocket connections, real-time resource monitoring, live output streaming, and instant status updates across the entire platform.

Accomplishments that we're proud of

We actually built everything we set out to build and then some:

✅ Complete marketplace with device listings, filtering, and geographic mapping

✅ VS Code extension with native IDE integration and AI assistance

✅ End-to-end encryption for secure code transmission

✅ AI-powered security analysis with intelligent threat detection

✅ Docker-based execution with resource monitoring and isolation

✅ Blender rendering workflow with cloud file management

✅ Real-time dashboards for both renters and lenders

✅ Interactive code editor with syntax highlighting and AI suggestions

✅ Session management with billing and resource tracking

✅ User authentication with email verification and security features

✅ Chat interface with AI assistant integration

✅ Project generation and development planning tools

✅ Geographic device discovery with distance-based filtering

✅ Performance optimization with pre-built Docker base images

The fact that you can literally write code in VS Code, click execute, and watch it run on someone else's GPU across the internet - that still feels like magic to us.

What we learned

Security is hard, really hard: Implementing proper encryption while maintaining usability taught us that security can't be an afterthought. Every feature had to be designed with security in mind from day one.

Docker is powerful but complex: Container orchestration, image optimization, and resource limiting required deep dives into Docker internals we didn't expect.

Real-time UX expectations: Users expect everything to be instant. Building real-time features while maintaining reliability across distributed systems pushed our backend design skills.

AI integration is more than just API calls: Creating meaningful AI features required understanding prompt engineering, model selection, and result processing to provide actual value to users.

VS Code extension development: Building native IDE integrations taught us about extension APIs, state management between processes, and user experience design within existing tools.

Cloud-first file management: Handling large files in distributed systems led us to implement streaming uploads, CDN optimization, and intelligent caching strategies.

What's next for ResourceX

Right now, Resource X works beautifully as a proof-of-concept, but we want to make this a production-level platform that actually changes how people access computing resources:

Production Infrastructure:

Kubernetes orchestration for scaling
Load balancing and auto-scaling
Advanced monitoring and alerting
Multi-region deployment

Enhanced Security:

Zero-knowledge proofs for privacy
Blockchain integration for transparent transactions
Advanced threat detection with ML models
Formal security audits

Platform Expansion:

Support for more languages and frameworks
Access through MCP servers inside Cursor IDE
Enterprise features and SLA guarantees

Economic Model:

Cryptocurrency payments for global accessibility
Dynamic pricing based on demand
Insurance and reputation systems
Developer tool integrations (GitHub, GitLab)

Community Features:

Resource pooling for large projects
Collaborative development environments
Educational partnerships with universities
Open-source project support

We're not just building another cloud platform - we're creating a future where computational power is truly democratized, where a student in any part of the world can access the same computing resources as a Silicon Valley startup, where idle hardware generates income for its owners, and where innovation isn't limited by infrastructure costs.

Resource X isn't just our hackathon project anymore - it's our vision for the future of computing.