What Eletric Man Actually Is
Eletric Man is a character recognition and OCR tool built for processing handwritten notes at scale. It uses a custom-trained transformer model paired with a preprocessing pipeline that handles skewed angles, varying pen pressures, and low-resolution scans. The standard pipeline includes deskewing, thresholding, and layout preservation before the text gets passed to the inference engine. The project lives on GitHub under the repository eletric-man/ocr-core. You pull it with git clone, then run the install script inside the setup/ directory. The main dependency chain is Python 3.10+, CUDA 12.1 if you are running on GPU, and a custom weights file that you download from the releases page. I skipped the CUDA path early on because my server stack is CPU-only, and it actually ran fine at about 400 documents per hour with the quantized model. If you need faster throughput, the full precision weights double that to roughly 800 docs per hour, but you need at least 16 GB of VRAM for that configuration. The config file sits at config/default.yaml and controls things like output format, language model fallback, and cache settings. By default it outputs JSON with bounding box coordinates. I switched mine to plain text with line breaks because downstream validation was choking on the coordinate data. The change took about two seconds to implement.
How It Works Under the Hood
Eletric Man processes documents in three stages. First, the preprocessing module normalizes the input image. It detects the document boundaries, corrects perspective distortion, and applies adaptive thresholding. This stage usually takes 0.3 to 0.8 seconds per page depending on resolution. Second, the segmentation module breaks the page into text lines and isolated characters. The third stage runs the recognition model, which outputs token probabilities that get decoded using a beam search with a custom language model reranking step. One thing most people miss is that the language model reranking is optional and disabled by default. Enabling it improves accuracy on cursive handwriting by about 12 percent on my test set, but it adds roughly 2 seconds per page. If you are processing typed or print handwriting, disabling it saves time with almost no accuracy drop. The tradeoff only matters when you are dealing with large batches where that 2 second difference compounds across thousands of pages.
Common Problems and What Actually Fixes Them
The biggest issue I ran into was inconsistent handling of overlapping text. The default segmentation assumes clean line separation, which is fine for most printed forms but falls apart on densely annotated documents where margin notes cross into the main text block. I hit this on a batch of medical intake forms from 1998 where the handwriting bled into adjacent fields. The model was merging two separate answers into one token sequence. The workaround was to adjust the segmentation threshold in the config. I lowered the line separation distance from the default 18 pixels to 8 pixels and added a post-processing rule that splits merged tokens at known field boundaries. That fixed the overlapping text problem without requiring any model retraining. It added about 0.4 seconds per page to the preprocessing stage, but the accuracy gain was worth it. Another edge case involves colored ink on dark backgrounds. The thresholding module is designed for black ink on white paper. When I processed some archival documents with blue fountain pen ink on aged cream paper, the standard pipeline treated the background as part of the text. I solved this by running the input through a color inversion step before thresholding. The config has a preprocessor override section for exactly this scenario.
Get the Full Details
When Eletric Man Falls Short
The tool struggles with highly stylized handwriting, particularly calligraphic scripts or abbreviations that do not appear in the training data. The model was trained primarily on standard American handwriting from the 1970s through the 2010s. Older documents with period-specific abbreviations or non-standard spellings have error rates around 18 to 22 percent without the language model reranking enabled. If you are working with historical documents that fall outside that training distribution, I would recommend running Eletric Man as a first pass and then manually reviewing only the low-confidence predictions. The confidence scores are reliable indicators. Anything below 0.65 confidence should get human review. This approach cut my review time from full document inspection to about 15 minutes per 100-page batch. For extremely poor quality scans where the original document is damaged or faded, no OCR tool will give you reliable results. Eletric Man is no exception. In those cases, manual transcription or hiring a specialized digitization service is the only realistic option. The model confidence scores will flag these cases automatically, but it cannot recover information that is not there.
Performance Numbers
On a standard workstation with an i7 processor and 32 GB of RAM, Eletric Man processes roughly 400 pages per hour using the quantized model. A GPU with 16 GB of VRAM pushes that to about 800 pages per hour. The preprocessing step accounts for about 40 percent of total runtime, and the recognition step accounts for the remaining 60 percent. Optimizing the preprocessing parameters usually gives you the biggest performance gains without touching the model itself. The caching system stores processed pages in a SQLite database by default. If you are reprocessing the same batch after changing config settings, enabling the cache invalidation flag forces a clean reprocess instead of serving stale results. I lost about three hours debugging incorrect output before realizing the cache was serving old data. The cache TTL is set to 24 hours by default, which is fine for one-time runs but problematic if you are iterating on config parameters.
Alternatives to Consider
If Eletric Man does not fit your use case, Tesseract with a custom LSTM model is a free alternative that handles typed text well. Kraken is another open-source option that works better for historical documents with degraded quality. Both require more manual configuration than Eletric Man, and neither has the same out-of-the-box preprocessing pipeline. If you need to process large volumes of standard handwriting quickly, Eletric Man is still the most practical choice. For specialized historical work, Kraken tends to produce better results on damaged documents. I have been running Eletric Man in production for about a year across multiple document batches. The setup is straightforward once you understand the config structure, and the documentation covers the basics adequately. Where it falls short is in handling unusual input types, so expect to spend some time tuning the preprocessing parameters for your specific use case. The quantized model is a solid starting point, and the full precision weights are worth upgrading to if your accuracy requirements demand it.
