Week 2: DNA Nanostructures

Summary

This week's lecture was about the design and experimental implementation of DNA origami. DNA origami is the folding of DNA to create non-arbitrary two- and three-dimensional shapes at the nanoscale. The specificity of the interactions between complementary base pairs make DNA a useful construction material, through design of its base sequences. DNA is a well-understood material that is suitable for creating scaffolds that hold other molecules in place or to create structures all on its own.

We learned how to design DNA origami using cadDNAno software. cadDNAno simplifies and enhances the process of designing three-dimensional DNA origami nanostructures. Through its user-friendly 2D and 3D interfaces it accelerates the creation of arbitrary designs. The embedded rules within cadDNAno paired with the finite element analysis performed by CanDo, provide relative certainty of the stability of the structures.

Fig.1: caDNAno program developed in William Shih's laboratory.

Design Assignment

1. Build flattened Rothemund rectangle in cadDNAno

To begin with, I designed the flattened Rothemund rectangle using caDNAno 2.0 software for Mac OSX. The design experience was not as frustrating as expected, and actually the second version has an undo feature, unlike the legacy one, which is really helpful. In Fig. 2 you can see the scaffold DNA strand in blue and the staples strands in black. There are some great tutorials on how to use caDNAno on their Youtube channel.

Fig.2: Flattened Rothemund rectangle.

2. Generate staple strand sequences in caDNAno

Subsequently I generated the staple strands sequences using the built in function of caDNAno and stored them in the text file you can see on figure 3.

Fig.3: Sequences for staple strands generated from caDNAno.

3. Color staple strands to create a black-and-white pattern in caDNAno

Fig.4: JSON file output for the black-and-white pattern in cadDNAno.

4. Generate ASCII file black-and-white image

The generated files for the homework can be downloaded from here.

Fig.5: Generated pattern in ASCII format.

5. Generate list of wells to pipet to generate black-and-white pattern

By parsing the black-and-white ASCII pattern, we selected the appropriate empty and dumbbell staple DNA oligos from the respective 96-well plates. You can see the compiled pipeting instructions in Fig. 5. (The list is given in a 2D format, but it is essentially linear; you pipet everything and mix!

Fig.6: Pippeting instructions to generate the Rothermund rectangle.

Extra-Credit Design Assignment

1. Generate caDNAno-format json file encoding 24 strand flat rectangle from a Python script

I coded the snippet needed to generate the 24 scaffold strands, join them and produce the Rothemund rectangle. The files for the extra credit assignment can be downloaded here.

# Build 24 scaf strands
for strand_num in range(num_strands):
	vstrand = copy.deepcopy(proto_vstrand)
	vstrand['num'] = strand_num
	vstrand['row'] = 12
	vstrand['col'] = 4 + strand_num
	inc = 1 - 2*(strand_num%2)
	vstrand['scaf'] = [[strand_num, base_num - inc, strand_num, base_num + inc] for base_num in range(16, num_bases - 16)]
	vstrand['scaf'] = [null_bpp]*16 + vstrand['scaf'] + [null_bpp]*16
	vstrands.append(vstrand)

# Join the 24 scaf strands
for strand_id in range(num_strands-1):
	join_strand_FN(vstrands, 'scaf', [strand_id+1, 16], [strand_id, 16])
	join_strand_FN(vstrands, 'scaf', [strand_id, num_bases - 17], [strand_id+1, num_bases - 17])

for strand_id in range(1,num_strands-1):
 	join_strand_FN(vstrands, 'scaf', [strand_id+1, num_bases/2], [strand_id, num_bases/2])
 	join_strand_FN(vstrands, 'scaf', [strand_id, num_bases/2+1], [strand_id+1, num_bases/2+1])

# install skips to untwist the strip
for helix_num in range(num_strands):
	for repeat_num in range(6):
		vstrands[helix_num]['skip'][repeat_num*48 + 43] = -1

Experimental Assignment

Protocol

  • Order from IDT the four 96-well plates needed to render 1-bit patterns
    ~$1500–$2000 for this set of strands on the 10 nmol scale (request 6 nmol total: 60 µL at 100 µM in water)
    Assuming each pattern will consume 10 pmol per strand, this will be enough material to fold 600 patterns
  • Pipet strands (10 pmol each) to generate all patterns submitted by teams in the class
  • Fold patterns in a thermocycler in a volume of 100 µL per pattern
  • Check to see that the structures fold correctly by agarose-gel analysis of 15 µL aliquot
  • Find a partner (commercial or otherwise) willing to do AFM imaging of your samples
  • Submit your samples to that partner (only 1 µL required for imaging)

Ordering sequences

Unfortunately the pooling of orders for DNA strands did not happen yet.