Sentence Sequencer

Paired Ends / live assembly

Your sentence, written as DNA, shredded, and assembled again.

Type anything. This page encodes it as a circular DNA molecule, sequences it into short reads with 1% errors, and rebuilds it twice from the same reads. The only difference between the two results is whether the assembler is told which reads came from the same fragment. Nothing is precomputed. It all runs in your browser when you press the button.

Or try:

outside
read pairs, joined by a thin arc. Pink ticks are sequencing errors.
ring
your sentence, one tick per base (A C G T). The notch at twelve o'clock is the origin.
inside
contigs built without pairing. Pink ones are repeats, drawn everywhere they occur.
center arc
the assembly built with pairing.

Pairing ignored

Pairing used

Six of the read pairs


    
Each line is one fragment of your sentence: 32 bases read from the left end, 32 from the right, and an unread gap between. Highlighted bases are errors the sequencer made. The assembler sees only these letters and which two reads share a line.

  


  

    
Run sheet

    

  


  

    

      
What just happened

      
Each byte of your text became four bases, two bits per base. A fixed 24-base origin was added and the ends joined into a circle, the way a plasmid is built.

      
The sequencer cut random fragments from that circle and read 32 bases from each end, miscalling about one base in a hundred. The reads were counted as 21-mers. A 21-mer seen only once or twice is almost always an error, so reads containing one were repaired or dropped.

      
The surviving 21-mers form a de Bruijn graph. Wherever your sentence repeats five or more characters, the graph forks, and reads alone cannot say which branch follows which. The top result stops at every fork and reports the pieces.

      
The bottom result walks the same graph but keeps every fork alive as a competing path, then scores each path by how many read pairs land the right distance apart. The path that explains the most pairs wins.

    

    

      
Where this is simpler than a real genome

      
    
        
  • One strand only. Real libraries read both strands, so a real assembler also handles reverse complements.
    • 
        
  • Errors are substitutions at a flat 1%. No indels, no quality scores, no GC bias.
    • 
        
  • The assembler is given the fragment size range and the origin sequence. Real pipelines estimate the first and often have no equivalent of the second.
    • 
        
  • Keeping every candidate path alive works for a few hundred bases. It would not scale to a real genome.
    • 
        
  • Your original text is used in two places only: the exact-match check at the end, and positioning the contigs on the drawing. The assembly never sees it.
    • 
        
  • A repeat longer than the fragments still defeats it. Try the knock-knock example. That limit is real, and it is why long reads exist.
    •