Hi, I’m Himal Gautam.

When you build across AI, GIS, and full-stack apps, your toolkit becomes your map. Mine has evolved from late-night debugging in PyTorch to mapping tree crowns in ArcGIS and wiring sensors on a Raspberry Pi. These are the tools I reach for when I want to ship fast, keep it clean, and still understand the system under the hood.

🌍 ArcGIS Pro / QGIS — Where the Map Begins

Whether it’s zoning layers for municipalities or remote-sensed imagery, ArcGIS Pro and QGIS are the backbone of my spatial workflow.
ArcGIS Pro gives me enterprise-grade precision for cartography, geoprocessing, and topology validation.
QGIS, being open source, is perfect for rapid experiments and automations.

Pro tip: Export vector data as GeoPackage (.gpkg) — portable, single-file, and readable across both ecosystems.

# quick layer export example (QGIS)
Processing > Toolbox > Vector general > Package layers

⚙️ PyTorch + CUDA — Powering GeoAI

Most of my research pipelines depend on PyTorch accelerated by CUDA for model inference. Before running large jobs, I always verify the CUDA ↔ build matrix to avoid runtime nightmares.

# sanity check
python -m torch.utils.collect_env

This stack powers my integration of Meta’s Segment Anything 2 (SAM2) model — a transformer-based segmentation engine that detects everything from canopy outlines to man-made structures.

🗺️ Segment-Geospatial — From Pixels to Polygons

Segment-Geospatial bridges AI and GIS. It converts SAM masks directly into vector shapefiles, ready for analysis or web visualization.

from segment_geospatial import segment_image
segment_image("naip_tile.tif", output="mask_vector.shp")

This single function replaces hours of manual digitization, especially when mapping tree crowns from NAIP imagery or CHM rasters.

⚛️ React + Vite + Tailwind — Fast Front-Ends

When I switch from GIS to product prototypes, I rely on this trio:
• React for modular UI logic
• Vite for lightning-fast builds
• Tailwind for clean, responsive design without CSS bloat

They let me go from concept → polished app in one stack. For example, my RunSafe app used this setup to render dynamic route safety scores in real time.

npm create vite@latest appname -- --template react
cd appname
npm install
npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p

🧩 Node / Express — Backends Without the Drama

I keep my APIs minimal: a few endpoints, one purpose. Node.js + Express handle it gracefully.

app.get("/api/routes", (req, res) => res.json(routes));

No over-engineering — just reliable JSON backends that talk to the front end instantly.

🗃️ MongoDB Atlas — Databases at Hackathon Speed

When you need a backend in minutes, MongoDB Atlas is unbeatable. Cloud-native, free tier, no deployment hassle. I used it in Kozi.REST to store real-time sensor logs and user summaries, syncing instantly with the dashboard.

🔧 Raspberry Pi — When Software Meets Air

My go-to lab bench for ideas that need sensors. Whether it’s I²C readings from CCS811 or motion data from an MPU6050, the Pi runs simple Python scripts that validate hardware before scaling to production IoT.

import smbus2, time
bus = smbus2.SMBus(1)

That’s how Kozi.REST came to life — a small sleep-tracking device that talked to an AI backend.

🧾 References

• Meta AI (2024). Segment Anything Model 2 (SAM2).
• Esri (2023). ArcGIS Pro Documentation.
• PyTorch (2024). Getting Started with CUDA.

Getting Meta’s Segment Anything Model 2.1 (SAM 2.1) running on Windows comes down to a clean Python env, the right PyTorch ⇄ CUDA combo, and the model checkpoints. Here’s the streamlined path I use on Windows.

1) Environment & PyTorch (CUDA)

# create & activate (venv example; conda works too)
python -m venv .venv
.\.venv\Scripts\activate

# install PyTorch matching your CUDA (example: CUDA 12.4)
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124

# core deps
pip install opencv-python matplotlib notebook rasterio shapely

# verify CUDA availability & versions
python -c "import torch; print(torch.cuda.is_available(), torch.version.cuda)"

2) Clone & Install SAM2

git clone https://github.com/facebookresearch/segment-anything-2.git
cd segment-anything-2
pip install -e .

If the repo ships a download_ckpts.sh script, run it under Git Bash/WSL or download checkpoints manually from the model card and place them in a known folder (e.g., ./checkpoints/).

3) Quick GPU Smoke Test

import torch, cv2
from segment_anything_2 import build_sam2

device = "cuda" if torch.cuda.is_available() else "cpu"
model = build_sam2(checkpoint="checkpoints/sam2_hiera_b+.pt").to(device)

img = cv2.imread("your_image.jpg")[:,:,::-1]  # BGR→RGB
# minimal point prompt example (x=100,y=150)
point = [[100,150]]; label = [1]
mask = model.segment(img, point_coords=point, point_labels=label)
print("Mask shape:", mask.shape)

4) Troubleshooting Notes

• Match PyTorch wheel to your installed CUDA (and VS 2022 C++ build tools for any native extensions).
• If pip install -e .[demo] is flaky on Windows, install listed demo deps individually (OpenCV, Matplotlib, Jupyter).
• If CUDA isn’t detected, verify your PATHs and torch.cuda.is_available().

How SAM 2.1 Works (Quick Tour)

• Image Encoder (Hiera ViT): streams frames/images into multiscale embeddings.
• Prompt Encoder: points/boxes (sparse) and masks (dense) guide what to segment.
• Memory Bank + Attention: for videos, past-frame features guide current masks.
• Mask Decoder: transformer head outputs masks (and “object absent” when needed).
• Memory Encoder: writes current-frame results back to memory for future frames.

5) Geospatial: Segment-Geospatial (SAM on GeoTIFF)

Use segment-geospatial to run SAM/SAM2 on NAIP/CHM or other GeoTIFFs and export vectors for GIS.

pip install segment-geospatial

# Automatic mask generation (whole image)
from samgeo import SamGeo2
sam = SamGeo2(automatic=True, model_id="sam2-hiera-large")
sam.generate(image="sample_naip.tif", output="output_mask.tif")

Large scenes can yield hundreds of segments. If you hit uint8 save errors (IDs > 255), write as uint16 GeoTIFF or vectorize directly.

# Prompted prediction (click-like point)
sam = SamGeo2(automatic=False, model_id="sam2-hiera-large")
sam.set_image("sample_naip.tif")
mask = sam.predict(point_coords=[(x, y)], point_labels=[1])

Next Steps

• Vectorize masks to GeoJSON/Shapefile and dissolve/clean small fragments.
• Try HQ-SAM or domain-tuned variants for sharper edges.
• Batch tiles + optional text prompts (e.g., “building”) for class-specific extractions.

Kozi.REST is an AI-powered bedside sleep companion designed to help users understand and improve their sleep quality through environmental and behavioral data. I led the integration of Raspberry Pi sensors that monitored ambient temperature, humidity, sound levels, and body motion throughout the night. These readings were processed locally and summarized every morning through an AI-generated audio briefing created with Gemini API and ElevenLabs TTS. The system included a lightweight web dashboard that visualized sleep trends, identified anomalies, and delivered insights into how room conditions affect rest quality. Beyond just logging data, Kozi.REST personalized feedback using an adaptive AI model that adjusted its recommendations over time, bridging hardware sensing with ambient intelligence in a compact IoT setup.

Code Snippet (App route)

app.post('/summary', async (req, res) => {
  const data = await db.collection('night_logs').find({ date: today() }).toArray();
  const summary = await gemini.summarize(data);
  const mp3 = await elevenlabs.tts(summary);
  await sendToPi(mp3);
  res.json({ ok: true });
});

Code Snippet (Pi button → backend)

# on the Pi
GPIO.add_event_detect(BUTTON, GPIO.FALLING, bouncetime=250)
GPIO.add_event_callback(BUTTON, lambda ch: requests.post(API + '/summary'))

RunSafe was built to make outdoor running safer by merging geospatial analytics with environmental health data. The app retrieves live AQI (air-quality index) data and computes the “healthiest” route among multiple alternatives provided by Google Maps. I developed the backend pipeline that decodes route polylines, samples coordinate points, synchronizes them with hourly AQI data from Open-Meteo, and computes cumulative exposure scores for each route. The client visualizes these scores as color-graded paths, giving runners real-time comparisons. RunSafe also allows users to log daily symptoms (like coughing or fatigue) and auto-generates weekly health reports in PDF, formatted for physician review. The project was inspired by the Rice IDSO Challenge on Air Quality & Lung Health and aims to connect environmental data with individual health outcomes.

Code Snippet (AQI exposure)

const exposure = points.reduce((sum, p, i) => sum + aqiAt(p.time, p.lat, p.lng) * segLen(points[i-1], p), 0);
const best = routes.sort((a,b) => a.exposure - b.exposure)[0];

Code Snippet (Polyline decode)

import polyline
points = polyline.decode(route.overview_polyline)
# sample every ~50m for AQI lookups
sampled = sample_points(points, step=50)

Baymax is a virtual companion designed to provide accessible mental-health support through natural conversation and personalized recommendations. I handled the backend architecture—building a secure RESTful API, integrating MongoDB Atlas for encrypted session storage, and linking Stripe API for subscription-based access. The app leverages GPT-powered dialogue to simulate empathy-driven conversation while preserving data privacy and maintaining clinical relevance through curated response sets. The project’s goal was to bridge the gap between immediate emotional support and professional therapy access by offering a responsive, human-like interface for early-stage intervention.

Code Snippet (session create)

router.post('/session', async (req, res) => {
  const user = await users.ensure(req.body.email);
  const sess = await db.collection('sessions').insertOne({ userId: user._id, createdAt: new Date() });
  res.json(sess);
});

Code Snippet (Stripe checkout)

const session = await stripe.checkout.sessions.create({
  mode: 'subscription',
  line_items: [{ price: process.env.STRIPE_PRICE_ID, quantity: 1 }],
  success_url: ORIGIN + '/app',
  cancel_url: ORIGIN + '/pricing'
});

Dristi (“vision” in Nepali) is a smart mobility aid designed to enhance independence and safety for visually impaired individuals. Built entirely on Raspberry Pi OS, the prototype uses ultrasonic sensors to detect obstacles and GPS for navigation guidance. I engineered the system logic that triggers haptic feedback when objects are detected within defined proximity thresholds and synchronized alert intensity based on obstacle distance and direction. The project demonstrated how low-cost hardware and intelligent sensor fusion can transform assistive technologies—prioritizing accessibility, affordability, and real-time responsiveness.

Code Snippet (haptics)

if (distance <= 50) {
  motor.vibrate(map(distance, 0, 50, 255, 80));
}

Code Snippet (Ultrasonic read)

def distance_cm():
  GPIO.output(TRIG, True); time.sleep(0.00001); GPIO.output(TRIG, False)
  start, end = pulse_in(ECHO)
  return (end - start) * 17150

Backlog Buddy is a small AI agent hosted on Cloudflare that helps a developer triage and act on their issue backlog. You chat with it in plain English, and it replies with a concrete plan: which issue to work on, what git branch to create, and which commands to run next.

Under the hood, a BacklogAgent Durable Object stores a seeded list of issues plus recent notes. Each message is appended to that state, then the agent builds a prompt with the backlog + conversation and calls @cf/meta/llama-3.3-70b-instruct-fp8-fast via Workers AI. Responses are streamed back through the Worker to the chat UI.

Responsibilities

• Designed the agent’s state model (issues, notes, lastUpdated) on top of Durable Objects.
• Implemented the chat endpoint and session routing so each URL session maps to its own agent.
• Built a minimal but responsive HTML chat UI served directly from the Worker.

Key snippet

// BacklogAgent — handle chat
  const result = await env.AI.run(
    "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
    {
      messages: [
        { role: "system", content: systemPromptWithIssues(issues) },
        { role: "user", content: userMessage }
      ]
    }
  );

  // update notes + lastUpdated, then respond back to the client
  return jsonResponse({ reply: result, state: { issues, notes, lastUpdated } });

MyGarage is a clean and minimal web app I built to keep track of the cars. It lets me add details like the make, model, year, mileage, fuel type, VIN number, and more. If anything changes like mileage or service date; I can update it. And when I no longer need a car in the list, I can easily delete it. What makes it more fun (and useful) is the Scan VIN feature. Instead of typing out the full 17-character VIN, I can just click a button, open my camera, and it reads the VIN directly from the image using Google Vision OCR. It’s quick, accurate, and saves time. The app is built using Node.js, Express, and MongoDB (via MongoDB Compass) running locally to store all the car data. It also uses WebSockets to sync changes across tabs or devices in real time so if I update something on my phone, it instantly updates on my laptop too. The frontend is built with vanilla JavaScript and Tailwind CSS for a simple but sharp retro look.

Code Snippet (tooling)

#!/usr/bin/env bash
# bootstrap a new package
pnpm create vite my-tool --template react
cd my-tool && pnpm i