With ref to the recent thread on reverse-engineering the SID chip, I though it might be worth sharing a couple of tools we made within the visual6502 community. These tools are not finished and were never used in anger, but they might be an interesting start, or an inspiration, for anyone wanting to tackle the problem of capturing polygons from chip layouts.

There is a client and a server, and the idea is for the client to be run by as many people are interested, and to capture polygons for small portions of the chip in a session of about 15 mins work. A person does as many sessions as they feel like, when they like. Each session should capture one layer of one tile. The server collects the data and puts it together. It can show overall progress and show each contribution.

In principle the server can ask several people to do each tile, and work out which tiles are accurate by fuzzy comparison, and rank people according to accuracy so that the more reliable people's tiles don't need quite so much confirmation as the less reliable people. (Less reliable people could be malicious, playful, confused, or inexperienced.) I don't know if the server has any of that functionality at present.

Here's what the interface looked like when we last touched it:


You can have a play here.

There are several live forks on github - my forks are almost the latest code, so I will link to them.
https://github.com/BigEd/crowdsource-polygons
https://github.com/BigEd/crowdsource-server

In fact, having typed that, I see there's a README!

In doing these reverse-engineerings, we find several bottlenecks:
- finding the rare chip which can be destroyed
- doing the chemistry
- doing the photography
- stitching into a single enormous image (or two, if we deprocess the chip to remove metal)
- capturing polygons for each layer
- building a netlist from the polygons
- making a simulation running on the netlist
- putting that simulation on a website
and because of all these bottlenecks you don't see much new from visual6502 very often. The main site now offers the 6502, 6800, and ARM simulations. The wiki holds a number of findings and some related work as well as a table of progress on the many donated chips. (Progress is very very slow - I don't recommend making any further donations without prior discussion.) (I see now that the wiki doesn't yet mention the ARM work!)

Some of the successful efforts at capturing polygons have been one person using one tool - either photoshop or inkscape. (Collaboration should improve throughput but then it needs coordination.)

I should add: my own view on this kind of crowd-sourcing effort is that you need to make an extraordinarily simple interface. In the demo I think all you can do is drag rectangles. There might be a way to delete a rectangle. It's tempting to build a whole user interface worth of gadgets, but then you have a training and maintenance problem.

The other thing I think is crucial: have great respect for the time of your users. Their every contribution should be recognised, their effort in learning what to do should be respected. If you make changes, make them server-side and make them backward compatible. They have to believe that there will be a result, a digitised chip, and they have to have faith that their personal stats will be maintained.

I think these things because I'm thinking of a playable gamified approach to polygon capture - absolutely not for experts.

There is a need for a tutorial, or a training mode, or some materials - that's another barrier, because people who understand things are not always great at teaching.

There are of course resources and tools elsewhere: John McMaster keeps a wiki at
http://siliconpr0n.org/wiki/doku.php?id=capture