DEV Community: Pushpak Jaiswal

PushCode — AI-Powered Cloud IDE

Pushpak Jaiswal — Wed, 14 Oct 2026 14:16:20 +0000

PushCode — AI-Powered Cloud IDE (Hacktoberfest Week 2 submission)

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

PushCode is a modern, cloud-based development platform that provides an AI-powered coding assistant, secure containerized code execution, and a microservices-based backend for multi-language compilation and run-time isolation.

Who would pay for it?

Teams and companies that want a secure, cloud IDE to run and test code without exposing their environments.
Educational platforms that want an integrated, AI-guided coding experience for students.
Developer tooling vendors who want a hosted, secure sandbox for running untrusted code.

Problem solved

Removes local environment setup friction by letting developers run code inside secure Docker sandboxes.
Gives developers immediate AI assistance for generation, debugging, explanation, and refactoring.
Provides a microservices architecture that’s easier to scale and extend.

Demo

No public hosted demo is available yet. You can run it locally or with Docker Compose:

Repo: https://github.com/PUSHPAK-JAISWAL/pushcode-v2
Local (microservices): follow the README (start Eureka, Gateway, Security, AI, and Execution services)
Docker: docker compose up --build

Screenshots / GIFs are in the repository under docs/images (dashboard, editor, assistant, execution, docker sandbox).

Code

All source code is in the repository:
https://github.com/PUSHPAK-JAISWAL/pushcode-v2

Key folders:

gateway — Spring Cloud Gateway entrypoint
security — Authentication/authorization service (JWT, BCrypt)
agentic — AI agent service (LangChain4j + LLM integration)
execution — Docker sandbox and multi-language execution service
eureka — Service discovery (Netflix Eureka)
docs — screenshots and API docs
docker-compose.yml — orchestration for local development

How I Built It

Backend: Java 21 + Spring Boot microservices (Gateway, Security, AI Agent, Execution Service, Eureka)
AI: LangChain4j for the agent orchestration, Groq API as an LLM backend, and intended use of GPT-OSS-120B models
Execution sandbox: Docker containers for language isolation, with runtime and memory limits
Database: MongoDB Atlas for persistence (Spring Data MongoDB)
DevOps / Local Run: Docker Compose to bring up services together
Frontend: React / Next.js (architecture shows a React/Next frontend for the editor and dashboard)
Tools: Maven, Git, VS Code / IntelliJ

Design highlights

Stateless JWT authentication and role-ready design
Secure code execution with isolated containers and limits
AI-driven features: generate, explain, debug, refactor, and algorithm optimization

Why Does Open Innovation Matter?

Open innovation made PushCode possible in three big ways:

Shared building blocks: Open-source frameworks like Spring Boot, LangChain4j, and language runtimes mean I could assemble a production-like microservices architecture quickly instead of reinventing core plumbing.
Community feedback & extensibility: By keeping the project public, contributors can extend supported languages, add new LLM backends, improve sandbox security, and integrate with CI/CD and IDE extensions.
Reproducibility and trust: Open source lets auditors and maintainers inspect the sandboxing and security choices so teams can deploy with confidence — a closed system would obscure those important implementation details.

Open innovation also enables research and smaller teams to build on top of large, community-maintained models and tools without prohibitive costs.

My Agent Session

(Optional) I do not have a saved public agent session to attach for this submission. If you have a saved DevRelay session or transcript, it can be embedded here for judges.

My First User

(Optional) No public early-adopter report yet. If someone tries it, add the name, feedback, and whether they paid here.

Prize Categories

I’m entering PushCode in the following categories:

AI / Agent tooling
Developer tools & productivity
Cloud / DevOps & security
Education & learning tools

How to try it locally (quick)

Clone:

git clone https://github.com/PUSHPAK-JAISWAL/pushcode-v2.git
cd pushcode-v2

Start services (or run each service with mvn spring-boot:run):

docker compose up --build

Explore the API endpoints (see README for /api/auth, /api/ai/*, /api/execute)

What I’d love help with

Frontend (Monaco editor integration, file explorer)
Adding more language runtimes and secure resource policies
LLM backend integrations and agents tuning
CI/CD, tests, and hardened sandboxing

CyberMaze 3D: Turn Your Phone into a Tactical Warfare Game That Gets You Outside

Pushpak Jaiswal — Wed, 07 Oct 2026 16:15:39 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

CyberMaze 3D is an addictive cyberpunk tactical maze warfare game that genuinely incentivizes real-world outdoor activity. Built entirely in Kotlin with Jetpack Compose, it combines four interconnected gaming pillars:

⚔️ Syndicate Infiltration Raids – Real-time strategic battles where you deploy cyber troops and cast tactical spells to assault rival mazes
🏰 Cyber Fortress Builder – Design your own 8×8 neon maze defense by placing walls and turrets to trap invaders
🛰️ Real-World Outdoor Radar – A game-changer: Connect your device's motion sensors. Walking outside awards 2× rewards, and reaching physical milestones (100 steps = 80m, 500 steps = 350m) unlocks actual in-game resources from virtual "Darknet Nodes"
🧠 Multi-Provider LLM Integration – AI tactical intelligence using OpenRouter models for live raid analysis, base defense audits, and procedural level generation

The gameplay loop creates a natural compulsion: "Need more resources? Go outside!"

Demo

Deployed Website: CyberMaze 3D Official Site

YouTube Video: [Watch the full gameplay & development walkthrough]
[https://youtube.com/shorts/f-WLxY41G0g?si=q07-qMeH-DEBSQZo]

Download: Direct APK download available from GitHub Releases with automatic in-app updates

Code

Full Repository: PUSHPAK-JAISWAL/CyberMaze-3D

I built this using open-source code as the foundation with:

95.3% Kotlin + Jetpack Compose M3 for pixel-perfect UI with taste-driven design
React 19 + Vite + Tailwind CSS for the website frontend – crafted with strong attention to visual taste and UX
3D Axonometric Rendering with custom canvas painter's depth sorting
SQLite Room Database for persistent game state
Android Sensor Framework Integration (TYPE_STEP_DETECTOR, TYPE_PRESSURE, TYPE_ACCELEROMETER, TYPE_ROTATION_VECTOR)
OkHttp Streaming for GitHub Releases API and LLM REST endpoints
GitHub Pages CI/CD for continuous deployment

How I Built It

This project leverages open-source AI and open-code foundations in a revolutionary way for mobile gaming:

BYOK (Bring-Your-Own-Key) LLM Architecture with OpenRouter: Players can configure their own API keys and route through OpenRouter models (accessing Gemini, Groq, OpenAI, and more) with zero vendor lock-in.
Live Tactical Recon: During raids, tap "AI INTEL" to let the LLM analyze enemy turrets and suggest attack strategies
AI Defense Auditing: Tap "AI AUDIT" in base builder to receive security ratings (S/A/B/C) and defensive recommendations
Neural Procedural Generation: Uses LLM embeddings to synthesize custom sector layouts with adaptive hazards based on real sensor movement
Offline Fallback: Local procedural engines ensure 100% playability without internet, with optional AI enhancement when configured
Taste-Driven Frontend: The website and in-game UI were designed with meticulous attention to cyberpunk aesthetics, visual hierarchy, and player experience—every pixel intentional.

The framework proves that open LLMs aren't just for chat—they're powerful tools for real-time game intelligence and adaptive design.

Why Does Open Innovation Matter?

Player Privacy & Control: Unlike closed APIs that phone home every interaction, players own their LLM keys through OpenRouter. Their tactical discussions stay private.
Cross-Model Strategy: Players can benchmark different models through OpenRouter—no single vendor holds their experience hostage.
Offline-First Design: The game ships 100% playable without internet. AI is an enhancement, not a gatekeeper.
Transparent Procedural Generation: The entire neural sector synthesis logic is open-source. Players can audit how the game builds levels.
Academic & Modding Potential: Students, researchers, and modders can fork the codebase, experiment with new LLM integrations, or build custom game logic—impossible with closed engines.

Open innovation made this "AI game" actually empower players instead of monetizing their data.

Prize Categories

🏆 Open-Source AI Innovation
🏆 Mobile Gaming / Game Development
🏆 Hackathon / Rapid Development
🏆 Sensor Integration / IoT
🏆 GitHub Developer Tools (Auto-update CI/CD system)

Scout - an intelligent autonomous open-source companion.

Pushpak Jaiswal — Fri, 02 Oct 2026 13:27:57 +0000

What I Built

Finding authentic, relevant open-source projects to contribute to is overwhelming—especially during Hacktoberfest. My close friend and college peer was stuck in endless repository searches: filtering through dead repositories, outdated labels, non-reproducible environments, and ambiguous issue descriptions. Every October, contributors want to dive in, but they spend 80% of their time scouting for issues that match their exact stack and experience level, only to hit a wall.

To solve this, I built Scout—an intelligent, autonomous open-source triage and scout companion designed to discover, inspect, and evaluate open-source opportunities tailored to a developer's specific skillset.

Instead of treating issue discovery as basic keyword matching, Scout uses open-source AI to act as a personal code scout:

Analyzes project health, maintainer responsiveness, and contribution barriers.
Parses complex repository dependency trees, issue discussions, and pull request conventions.
Explains the codebase context behind an issue and drafts tailored getting-started roadmaps so the contributor can start hacking immediately.

📷

Demo

Experience Scout in action:

Video Walkthrough:

Code

The complete source code for Scout is open source and hosted on GitHub:

PUSHPAK-JAISWAL / Scout

Single-file desktop app for finding GitHub issues you can actually do. Written in V.

Scout

Single-file desktop app for finding GitHub issues you can actually do. Written in V.

Setup (once, or after updating the webview module) v ~/.vmodules/ttytm/webview/build.vsh (Linux/macOS) v %USERPROFILE%.vmodules\ttytm\webview\build.vsh (Windows PowerShell)

Install deps: v install ttytm.webview Linux also needs: sudo apt install libgtk-3-dev libwebkit2gtk-4.0-dev

Build: build.bat (Windows) or ./build.sh (Linux/macOS) Run: Scout.exe or ./Scout — opens in its own native window, no browser, no console Run: Scout.exe (opens its own window, no browser tabs to manage)

Data (keys, skills, issues) is stored in a data\scout.db folder next to Scout.exe — copy or move the whole Scout folder and your data goes with it, same as a portable app. If that folder can't be written to (e.g. Scout sits in Program Files), it falls back to %APPDATA%\Scout\scout.db The server listens only on 127.0.0.1:8787. The UI is embedded in the exe. Everything is entered in the app: tokens, skills you know, skills you…

View on GitHub

Feel free to star, fork, and inspect the architecture.

How I Built It

Scout was architected with a strict focus on minimalism, raw compiled execution speed, open-weight language models, and zero platform lock-in.

Architecture & AI Stack

Compiled Performance with V (Vlang): The core application and CLI/runtime are written entirely in the V programming language. V compiles directly to clean C or machine code with zero dependencies, sub-second compilation times, and a tiny memory footprint. This makes Scout blazingly fast and easy to distribute as a single static binary without heavy node modules or virtual environments.
Open Code Harness & Autonomous Tooling: The reasoning and task execution loop is managed via an open code harness. Rather than relying on rigid, closed frameworks, the harness coordinates structured execution pipelines to:
Perform live repository exploration and file-tree parsing via GitHub APIs.
Run code context analysis and calculate issue difficulty scores.
Generate structured, step-by-step contribution roadmaps for the user.
Open-Weight Intelligence via Groq (GPT-OSS-120B):
Scout leverages GPT-OSS-120B, a powerful open-weight language model, accessed through Groq's LPU inference API. This delivers near-instantaneous token generation speeds for issue summarization, diff explanations, and codebase triaging without waiting on high-latency proprietary backends.
BYOK (Bring Your Own Key) Architecture:
Scout operates on a transparent, client-side BYOK model. Users provide their own API credentials directly. No user requests or repository tokens pass through an intermediary backend proxy, guaranteeing complete user ownership, zero vendor lock-in, and zero operational markup.
Embedded State with SQLite (No Heavy Vector DBs):
Instead of introducing the overhead and operational friction of standalone vector databases, Scout uses an embedded SQLite engine. SQLite manages structured schema caching, repository metadata indexing, local history, and state tracking directly on disk with zero external dependencies.

Why Does Open Innovation Matter?

When building developer tooling—especially tools meant for the open-source community—relying on closed, proprietary AI APIs is counter to the mission:

Freedom from Walled Gardens & BYOK Autonomy: Closed AI services tie developers to opaque pricing structures, unpredictable rate limits, and sudden policy shifts. By combining open-weight models like GPT-OSS-120B with a BYOK architecture, Scout ensures that the developer remains in complete control of their credentials, costs, and infrastructure.
Auditable, Verifiable Tooling: Developer tools must be trustworthy. An open stack—from the V codebase and open code harness down to the open model weights—allows anyone to audit how code is parsed, how issues are evaluated, and how prompts are structured. There are no hidden telemetry scripts or proprietary prompt injections.
Resource Efficiency & True Portability: Open innovation allows us to pair modern, highly efficient languages like V and embedded SQLite with high-throughput inference engines. This proves that you don't need complex, multi-service bloatware or heavy enterprise cloud tiers to build capable, production-grade AI developer tools. ---

Team & Author

Pushpak Jaiswal (LinkedIn | GitHub)

DEV Community: Pushpak Jaiswal

PushCode — AI-Powered Cloud IDE

PushCode — AI-Powered Cloud IDE (Hacktoberfest Week 2 submission)

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

My First User

Prize Categories

How to try it locally (quick)

What I’d love help with

Links

CyberMaze 3D: Turn Your Phone into a Tactical Warfare Game That Gets You Outside

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Scout - an intelligent autonomous open-source companion.

What I Built

Demo

Code

PUSHPAK-JAISWAL / Scout

Single-file desktop app for finding GitHub issues you can actually do. Written in V.

Scout

How I Built It

Architecture & AI Stack

Why Does Open Innovation Matter?

Team & Author