DEV Community: Summer Zhao

I Built a Solo Murder Mystery Game Where You Interrogate AI Suspects

Summer Zhao — Sat, 20 Jun 2026 10:37:14 +0000

I've always loved detective fiction but hated how most mystery games railroad you into preset dialogue options. So I built something different.

Murder Mystery AI is a browser-based solo detective game where the suspects are actually AI-powered. You type questions in natural language, and they respond in character. No preset trees. No "pick option A, B, or C." Just you, your questions, and a bunch of virtual suspects who may or may not be lying to you.

The Womb House is the first case. It's a horror-tinged family mystery set in a villa with missing square footage, a torn wedding photo, and an attic that whispers. You play as the detective sent to figure out what happened to a missing witness. There are four suspects — each with distinct personalities, alibis, and secrets. Some are cooperative. Some are evasive. One of them might be the killer.

What makes it work is the combination of freeform interrogation and physical evidence. You can search rooms, examine objects, and cross-reference what you find against what suspects tell you. If someone claims they were in the garden at midnight but you found a muddy footprint in the hallway, you can call them out on it.

Each case runs 60-90 minutes, depending on how thorough you are. The current one is expert difficulty, which means suspects are less forthcoming and the evidence is more ambiguous. I've watched playtesters spend twenty minutes arguing with a virtual suspect about a torn photograph, only to realize the real clue was in the room description they skimmed past.

The tech stack is fairly straightforward — React frontend, Claude API for the AI suspects, and a state management system that tracks what each suspect knows, what they've admitted to, and what they're still hiding. The interesting engineering challenge was building a prompt pipeline that keeps suspects in character while still allowing them to react dynamically to unexpected player questions. A butler shouldn't break character to discuss quantum physics, but he should be able to lie convincingly about his whereabouts.

It's free to play, no account needed. I'm sharing it here because I'm curious how the dev community approaches narrative AI — especially the balance between "character consistency" and "meaningful player agency." If you try it, let me know which suspect you broke first.

https://murdermysteryai.com

Building Privacy-First Bioinformatics Tools in the Browser: A Technical Deep Dive

Summer Zhao — Sat, 20 Jun 2026 07:23:08 +0000

When researchers paste DNA sequences into online tools, they rarely consider where that data goes. Yet a single gene sequence could represent months of lab work, unpublished findings, or even patent-pending discoveries. This is why I believe browser-based bioinformatics tools should be built with privacy-by-design principles — processing everything client-side whenever possible.

The Problem with Cloud-Based Bioinformatics

Most bioinformatics platforms follow a familiar pattern:

User pastes sequence data into a web form
Data travels to a remote server for processing
Results are computed and sent back

This creates several concerns:

Data sovereignty: Your sequences pass through infrastructure you don't control
Compliance: HIPAA, GDPR, and institutional IRB requirements may be violated
Retention: You rarely know how long your data is stored
Trust: Even reputable services can have breaches

A Better Approach: Client-Side Processing

Modern browsers are surprisingly powerful. With pure JavaScript, we can perform complex sequence analysis without ever sending data to a server.

Example: Reverse Complement in Browser

Here's how simple it is to compute the reverse complement of a DNA sequence entirely client-side:

function reverseComplement(sequence) {
  const complement = { 'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G', 'N': 'N' };
  return sequence
    .toUpperCase()
    .split('')
    .reverse()
    .map(base => complement[base] || 'N')
    .join('');
}

// Runs entirely in the browser — zero network requests
const dna = "ATGCGTACGTTAGC";
console.log(reverseComplement(dna)); // "GCTAACGTACGCAT"

Example: GC Content Calculation

function gcContent(sequence) {
  const gc = (sequence.match(/[GC]/gi) || []).length;
  return (gc / sequence.length * 100).toFixed(2);
}

Example: ORF Finder

Finding open reading frames requires scanning for start (ATG) and stop codons (TAA, TAG, TGA):

function findORFs(sequence, minLength = 100) {
  const stopCodons = ['TAA', 'TAG', 'TGA'];
  const orfs = [];

  for (let frame = 0; frame < 3; frame++) {
    for (let i = frame; i < sequence.length - 2; i += 3) {
      const codon = sequence.slice(i, i + 3);
      if (codon === 'ATG') {
        // Found start, now look for stop
        for (let j = i + 3; j < sequence.length - 2; j += 3) {
          const check = sequence.slice(j, j + 3);
          if (stopCodons.includes(check)) {
            const length = j + 3 - i;
            if (length >= minLength) {
              orfs.push({ start: i, end: j + 3, length, frame });
            }
            break;
          }
        }
      }
    }
  }
  return orfs;
}

Translation Without a Server

DNA-to-protein translation using the Standard Genetic Code is just a lookup table operation:

const codonTable = {
  'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L',
  'CTT': 'L', 'CTC': 'L', 'CTA': 'L', 'CTG': 'L',
  'ATT': 'I', 'ATC': 'I', 'ATA': 'I', 'ATG': 'M',
  // ... full table
};

function translate(dna) {
  let protein = '';
  for (let i = 0; i < dna.length - 2; i += 3) {
    protein += codonTable[dna.slice(i, i + 3)] || 'X';
  }
  return protein;
}

When Server Communication IS Needed

Some operations legitimately require external data:

Fetching GenBank records by accession number
Querying UniProt protein databases
Retrieving reference genomes

For these cases, only the public identifier should be transmitted — never the full sequence. The server sends back the public record, and all analysis happens client-side.

Practical Considerations

Performance

Modern JavaScript engines handle multi-megabyte sequences efficiently
Web Workers can offload heavy computations to background threads
For very large datasets (NGS reads), streaming processing is feasible

Limitations

Cannot access local files without user permission (File API)
Memory constraints for extremely large sequences (>100MB)
No access to GPU acceleration for alignment algorithms (WebGPU is changing this)

Browser Compatibility

All techniques described work in every modern browser. No WebAssembly, no Service Workers, no experimental APIs — just vanilla JavaScript.

Why This Matters

Building bioinformatics tools that respect user privacy isn't just about compliance. It's about:

Enabling research in regulated environments (clinical labs, pharma companies)
Protecting unpublished data from competitors or scooping
Removing barriers for students and researchers in institutions with strict IT policies
Building trust with users who may not be technical enough to audit data practices

Conclusion

The browser has evolved from a document viewer to a capable computation platform. For many bioinformatics workflows — sequence manipulation, primer design, restriction analysis, codon optimization — client-side processing is not only possible but preferable.

If you're building tools for life scientists, consider what computations truly need a server. You might be surprised how much you can do without one.

I've been building SeqBench with these principles in mind — a free, browser-based suite of bioinformatics tools where sequence data never leaves your device. Would love feedback from the dev community on the approach.

I Built SeqBench - Free Bioinformatics Tools in the Browser

Summer Zhao — Fri, 19 Jun 2026 17:18:39 +0000

SeqBench is a free, browser-based bioinformatics toolkit designed for molecular biologists, bioinformaticians, and students working with DNA, RNA, and protein sequences.

Why I Built It

Most bioinformatics software is either:

Expensive (SnapGene $200+/year)
Bloated and slow to open
Requires installation on every device

I wanted something lightweight, private, and instantly accessible for quick sequence checks in the lab.

Key Features

15+ integrated tools: reverse complement, translation, ORF finder, primer Tm, CRISPR gRNA designer, plasmid viewer, codon optimizer, restriction analysis, FASTA/FASTQ stats, pairwise alignment, and more
Privacy-first: most calculations run locally in your browser — your sequences don't leave your device
Zero friction: no registration, no installation, no paywalls
Database integration: fetch sequences from GenBank, RefSeq, and UniProt using just accession numbers
Educational resources: built-in guides and reference tables for students

Use Cases

Quick sequence checks without opening heavy desktop software
Teaching molecular biology and bioinformatics
Primer design and validation
CRISPR guide RNA screening
Learning sequence analysis fundamentals

Try it out at seqbench.com

Would love feedback from the bioinformatics and developer communities!