Changes Between the 2007 and 2011 ESV Text

The recent revision to the ESV text in 2025 piqued my interest to see how much the translation has changed since its release in 2001. This post is the first of several and will explore the second revision to the ESV text and how I used local language models to find the differences.

Posted Jan 20, 2025

By userjrd

95 min read

ESV has conveniently posted documents highlighting the changes for the 2016¹ and 2025² text editions on their website. Unfortunately I couldn’t find a similar document for the 2011 edition but I figured at one point it had probably been hosted on their website. After digging around I found an old blog post³ that linked to the 2011 change file that was no longer hosted. Thankfully someone had captured the link in the Internet Archive and I was able to access the changes.⁴

At this point I was confused because the only file I could download from this was an *.swf file which I had never encountered before. After some Googling I discovered it stood for Small Web File and was a defunct Flash format. Thankfully there are programs out there that can handle the format still. I chose an open source project called FFDec (Free Flash Decompliler)⁵ that was cross-platform compatible with MacOS, Linux, and Windows. Score!

I’m not sure if I did something wrong but I couldn’t get the MacOS version to launch so I installed the Linux version instead and it worked great. I don’t know anything about Flash files but in the file structure I found a folder of images and was able to save it to a folder. So now I was left with 27 pages of images of that the text needed to extracted from. The text changes were displayed in three borderless columns of “Bible Reference”, “Changed From”, and “Changed To”.

Optical Character Recognition (OCR)

Thankfully OCR isn’t that big of a deal and is simple to use (or so I thought). I found a Python project called img2table and it seemed like it was perfect.⁶ It took me a long time to even get it working which had to do with the library not knowing the path to the TesseractOCR on my computer. I got it working but I’m not entirely sure what it is I did in the end that actually fixed it. The following is the code I ended up with:

  
from img2table.document import Image
from img2table.ocr import TesseractOCR
import pandas as pd

# load image
img = Image(src='.raw/1.png')
tesseract = TesseractOCR()

# Extract tables with Tesseract
tables = img.extract_tables(ocr=tesseract,
  implicit_columns=True,
  implicit_rows=True,
  borderless_tables=True)

# combine each row
frames = [table.df for table in tables]
full_data_df = pd.concat(frames)

While this worked, the output was not very clean or accurate. Often times a single row in the image would appear as multiple rows and it didn’t consistently recognize spaces between words and end up notputtingspacesbetweenwords. Not ideal and with 27 pages to sort through I didn’t know if I could trust the output. So I changed course and looked at some large language model (LLM) vision language (VL) models.

Vision Language Models

VL models are like OCR+ that can understand more context of what you are trying to extract. Because the images I want to extract are in a borderless table format I think VL models would be a good bet instead of tinkering with traditional OCR. I used LM Studio to search for VL models and landed on Qwen2.5-VL-7B. (I tried Qwen3-VL-8B because it was newer but it didn’t seem to work as well).

I gave it the simple prompt: “The attached images have three columns of text for Bible Reference, Changed From, and Changed To. Extract the text from each image and display as a table.” After about 40 seconds (running on a 2024 Macbook Pro) the model spit out exactly what I was looking for in a nice Markdown formatted table. The only problem was that the context length of the model only allowed 4-5 images before it ran out of context space.

LM Studio has a Python API that I’ve never used before but I thought this would be a great usecase for it since I would need to do a repetitive action of creating a model, uploading the image, giving a prompt, and storing the result for each of the 27 images. Installation was easy with pip install lmstudio.

Another thing I needed to get rid of was the commentary the model provided before giving the actual results. LLMs love to talk about what they are doing. To avoid this I came up with the following prompt: “The attached image has three columns of text for Bible Reference, Changed From, and Changed To. Extract the text from the image and display as a table. I only want the table returned with no commentary”. The Python implementation ended up like this:

  
import lmstudio as lms
import time

basepath = '.raw/'

# extract table from each image
for i in range(1,27+1):
  start_time = time.perf_counter()
  filename = f'{i}.png'
  img_path = f'{basepath}{filename}'
  print(f'Extracting table from {img_path}...', end=' ')

  # create LM Studio model for each page
  with lms.Client() as client:
    image_handle = client.files.prepare_image(img_path)
    model = client.llm.model("qwen/qwen3-vl-8b")
    chat = lms.Chat()
    message = "The attached image has three columns of text for Bible Reference, " \
    "Changed From, and Changed To. Extract the text from the image and display as a table." \
    "I only want the table returned with no commentary"
    chat.add_user_message(message, images=[image_handle])
    prediction = model.respond(chat)

    # print execution time
    finish_time = time.perf_counter()
    total_time = finish_time - start_time
    print(f'Finished in {total_time:.3f} seconds')

    # append table to file
    with open('_tables/_esv2011revisions.md', 'a') as f:
      if i == 1:      # include header
        print(prediction.content, file=f)
      else:           # remove header
        table = prediction.content.split('\n')[2:]
        content = '\n'.join(table)
        print(content, file=f)

This took about 40 seconds for each page and finished in about 17 minutes on my Macbook Pro. A little long but honestly you can just hit go and make a cup of coffee. If I was doing this everyday I’m sure there are ways to skip the LLMs and get OCR to work. But honestly, I was tired of fiddling with it and the fact that this worked so well was surprising.

Making the Changes Pop

Not everything was perfect with using the LLM though. I wanted the model to also bold the word changes between the 2007 and 2011 version for readability. I thought I should be able to just add that to the prompt and let the model handle it but… no. For some reason the model would highlight the differences but also randomly make the same words and phrases bold as well. I’m not sure if this is a weird unicode thing where the words looked similar but were somehow different symbols, but I needed a better solution.

Little did I know that Python has a built-in difference library called difflib.⁷ I will forever be amazed by the power of the Python standard library. It has easy to use methods to create Git-style change highlighting for word replacements, insertions, and deletions. One limitation to using this library is that it doesn’t handle word order change For example, if you change “Here am I” to “Here I am” than both words show as replaced instead of swapped. Another struggle I had was harnassing the library to output the text in a format I wanted.

After some Googling I landed on using difflib’s opcode functionality. Basically an opcode is a description of how to change String A into String B. This results in tags indicating the type of transformation (equal, replace, delete, insert) and the location in each string. My usecase for the library is fairly niche so I thought it would be easiest just to create my own formatting functions for each tag case.

Since I had originally asked the VL model to output as a Markdown table I had to unfortunately go from Markdown table into a Pandas dataframe and then back into a Markdown table. Surprisingly this wasn’t as hard as I first thought. I could just load the Markdown table with the pd.read_csv() function and treat the | as delimeters. This unfortunately created empty columns for the first and last (because of how Markdown tables are formatted) but If I hand-selected my columns and ignored the second row (again, Markdown formatting) I could load the table into Pandas with a one-liner. Also, some of the excerpts had a single quote that Python didn’t like so I had to import the csv module and set quoting to none.

There are probably libraries available to generate Markdown tables from Panda dataframes but I just cheesed it and put in the manual text formatting with f-strings. Is it pretty? No. But it was really simple and worked. Using some if statements I can format each tag and add it to the cell text. If it’s equal I don’t change the formatting. If it is replaced I bold both cells and if it was deleted in the first column (2007) or inserted in the second column (2011) I make the text bold. Here is the final code.

  
import pandas as pd
import csv
import difflib

# load table from file
revisions = pd.read_csv('.tables/esv2011revisions.md',
  sep='|', skipinitialspace=True, usecols=[1,2,3],
  skiprows=[1], quoting=csv.QUOTE_NONE)

# create markdown table
md_table = '|Bible Reference|2007 Text|2011 Text|\n|---|---|---|\n'

# create sequence matcher
s = difflib.SequenceMatcher()

# iterate through changes
for index, row in revisions.iterrows():
  ref = row['Bible Reference ']
  text1 = row['Change From ']
  text2 = row['Change To ']
  changes1 = ''
  changes2 = ''

  # Get opcodes for word-level comparison
  s.set_seqs(text1.split(), text2.split())
  opcodes = s.get_opcodes()

  # format changes
  for tag, i1, i2, j1, j2 in opcodes:
    if tag == 'equal':
      # add unchanged words
      changes1 += f' {" ".join(text1.split()[i1:i2])}'
      changes2 += f' {" ".join(text2.split()[j1:j2])}'
    elif tag == 'replace':
      # Highlight changed words
      changes1 += f' **{" ".join(text1.split()[i1:i2])}**'
      changes2 += f' **{" ".join(text2.split()[j1:j2])}**'
    elif tag == 'delete':
      changes1 += f' **{" ".join(text1.split()[i1:i2])}**'
      # changes2 += f' **{" ".join(text2.split()[j1:j2])}**'
    elif tag == 'insert':
      # changes1 += f' **{" ".join(text1.split()[i1:i2])}**'
      changes2 += f' **{" ".join(text2.split()[j1:j2])}**'

  md_table += f'|{ref}|{changes1}|{changes2}|\n'

# save to file
with open('.tables/_esv2011revisions_formatted.md', 'w') as f:
  print(md_table, file=f)

# Markdown(md_table)

2007->2011 Changes

And just like that we have all the changes between the 2007 to 2011 ESV text edition extracted from the rasterized internet archive and put into a nice table you can copy or search. I’ll sort through all these changes in a later post but that’s enough for one blog post. Enjoy!

Sources

Theology, Bible Translation

This post is licensed under CC BY 4.0 by the author.