Appearance
OpenRefine keeps a complete, linear undo/redo history for every project, stored on disk in the project's change files, so you can step backward and forward through operations even after closing and reopening. The two errors that trip up almost everyone: redo vanishing after you make a new edit, and the inability to delete a single step from the middle. Both come from the same design fact — history is a single timeline, not a tree — and once you understand that, troubleshooting becomes straightforward.
Why did my redo steps disappear?
This is the most common confusion. The history is linear. When you click undo to step back three operations and then perform any new operation, OpenRefine branches the timeline: everything after your return point is discarded, and the redo stack is gone.
The fix is preventative: before experimenting, extract your operations as JSON (see below) so you can re-apply a discarded branch. There is no in-app "recover redo" button once you have made a fresh edit.
How is the history stored, and does it survive a restart?
History is not session-only. Each project folder in your OpenRefine workspace holds the data plus serialized change objects. Typical locations:
text
Linux: ~/.local/share/OpenRefine/<projectid>.project/
macOS: ~/Library/Application Support/OpenRefine/<projectid>.project/
Windows: %LOCALAPPDATA%\OpenRefine\<projectid>.project\Because operations are persisted, you can quit, reopen the project a week later, and the full undo/redo list is intact. That persistence is also why a project file can grow large — every reversible step is recorded.
Can I delete just one step in the middle?
Not directly. There is no selective undo. To surgically remove a middle operation:
- Go to the Undo / Redo tab and click Extract.
- Copy the JSON array of operations.
- Delete the unwanted operation object from the array in a text editor.
- Roll the project back to its starting state (undo to step 0).
- Click Apply and paste the edited JSON.
json
[
{ "op": "core/text-transform", "columnName": "name", "expression": "value.trim()" },
{ "op": "core/mass-edit", "columnName": "country", "edits": [ /* remove this one */ ] },
{ "op": "core/column-split", "columnName": "dates" }
]This rebuilds history without the offending step — far safer than re-doing dozens of clicks by hand.
How do I recover work after a crash?
Reopen the project. OpenRefine replays committed operations from the change files, so any completed step survives. The only thing at risk is an operation that was interrupted mid-write — usually the very last one. Diagnose it by checking the row count against what you expect, then re-run just that final step. Do not delete the .project folder while trying to fix a crash; that is the only copy of your history.
How do I share my exact steps with a colleague?
The Extract/Apply mechanism doubles as a reproducibility tool:
- Extract turns your whole history into a portable JSON operations list.
- A colleague opens the same source data, goes to Undo/Redo, clicks Apply, and pastes the JSON.
The replay is deterministic, so they reproduce your cleaned result byte-for-byte. Note that operations involving external reconciliation or fetch URL may differ if the remote service changed.
Quick diagnostic table
| Symptom | Root cause | Fix |
|---|---|---|
| Redo greyed out | New edit after undo branched history | Re-apply saved operations JSON |
| Can't remove one step | History is linear | Extract JSON, delete object, re-Apply |
| History gone after restart | Wrong project opened | Reopen correct .project folder |
| Result differs on replay | fetch/reconcile hit live service | Cache responses; pin a snapshot |
Key Takeaways
- History is linear and persisted to disk — it survives restarts but cannot branch.
- Redo is lost permanently the moment you make a new edit after undoing.
- There is no selective undo; edit the operations JSON and re-Apply to remove a middle step.
- After a crash, completed operations replay automatically; only the last in-flight step may be lost.
- Extract/Apply lets you share or rerun an exact cleaning history deterministically.
- Never delete a
.projectfolder while recovering — it holds the only copy of your work.
Frequently Asked Questions
Why did my redo steps disappear in OpenRefine?
Redo is destroyed the moment you perform a new operation after undoing. OpenRefine keeps a linear history, so stepping back and then editing branches the timeline and discards everything that came after the point you returned to.
Can I undo a single step in the middle of OpenRefine history?
No. History is linear, not selective. To remove one middle step you must roll back to before it, then re-apply the later operations, ideally by extracting and editing the operations JSON.
Where is OpenRefine history actually stored?
Inside the project's change files under your OpenRefine workspace directory, which on most systems lives in a hidden folder such as ~/.local/share/OpenRefine or the equivalent AppData path on Windows. Closing the app does not erase it.
Does OpenRefine history survive closing and reopening the project?
Yes. The full undo/redo timeline is persisted to disk with the project, so you can quit OpenRefine, reopen the project days later, and still step backward and forward through every operation.
How do I recover work after OpenRefine crashed mid-operation?
Reopen the project; OpenRefine replays committed operations from the change files, so completed steps survive. An operation interrupted mid-write may be lost, so re-run only the last step and verify the row count.
How can I share my exact cleaning steps with a colleague?
Use Extract on the Undo/Redo tab to copy the operations as JSON, then your colleague pastes it into Apply on their project. This replays your entire history deterministically on the same input.