Cook'n Migration: From 1992's Database to Modern Formats

Cook'n by DVO Enterprises has been around since 1992, making it one of the oldest recipe management applications still in active use. For over three decades, home cooks have been storing recipes in Cook'n -- which means there are people out there with collections spanning 20 or 30 years of family cooking.

That kind of longevity is both Cook'n's strength and the source of its migration challenge. The .ckn file format reflects design decisions made in the era of Windows 95, and getting data out of it requires understanding what is actually inside.

What Is a .ckn File?

A .ckn file is a ZIP archive containing an HSQLDB database. HSQLDB (HyperSQL Database) is a Java-based relational database that stores its data as SQL statements in a transaction log file. When you look inside a .ckn file, the key file is typically located at data/dvodb.log -- a plain-text log of SQL INSERT statements that represent the entire recipe database.

This is an unconventional storage format by modern standards, but it has a practical upside: because the transaction log is plain text, it is possible to parse it directly without needing to run an actual HSQLDB instance.

The Database Structure

Cook'n's database organizes recipe data across several tables, and the relationships between them carry meaning:

DESCRIPTOR table -- Contains recipe metadata including a unique ID, title, and description. Each entry has a type field; type 4 indicates a recipe (as opposed to other content types Cook'n manages).

RECIPE table -- Contains the cooking details for each recipe: instructions, servings, yield, cook time, prep time, and their human-readable string equivalents.

INGREDIENT table -- This is where it gets interesting. Cook'n does not store ingredients as simple text strings. Instead, each ingredient is broken down into components: an amount, a unit ID (referencing a master list of units), pre-qualifier text, post-qualifier text, a food ID, and a sort order. The pre-qualifier often contains the actual ingredient name, while the post-qualifier holds preparation notes.

UNIT table -- A lookup table mapping unit IDs to names. Cook'n has an extensive unit vocabulary -- not just "cup" and "tablespoon," but also descriptive terms like "large," "boneless," "chopped," and even "room temperature." There are hundreds of entries.

How MoveMyRecipes Parses It

When you upload a .ckn file to movemyrecipes.com/cookn, the parser does the following:

1. Opens the ZIP archive and locates the dvodb.log transaction log file.
2. Reads the log file in 1MB chunks to handle large databases without running into memory limits.
3. Scans for INSERT INTO DESCRIPTOR, INSERT INTO RECIPE, and INSERT INTO INGREDIENT statements using pattern matching.
4. Filters for type-4 descriptors (actual recipes, not other content).
5. Assembles each recipe by joining the descriptor, recipe data, and ingredients by their shared IDs.
6. Formats each ingredient by combining the amount, unit name, pre-qualifier, and post-qualifier into a readable string like "2 cups all-purpose flour, sifted."
7. Converts the assembled recipe into Schema.org format with proper field mapping.

The parser handles Cook'n-specific quirks: escaped quotes in SQL strings, unicode escape sequences, HTML links embedded in instructions (which are stripped but their text is preserved), and the \u000a newline encoding Cook'n uses instead of actual newlines.

Time strings in Cook'n can be unusual too. Rather than "1 hour 30 minutes," you might see "1 30 hrsmins" as a single string. The parser recognizes multiple time formats and converts them all to ISO 8601 durations.

What Transfers Well

• Recipe names and descriptions -- come through cleanly from the DESCRIPTOR table.
• Ingredients -- reconstructed from the component parts. The amount, unit, and qualifier fields combine into readable ingredient lines. Cook'n's extensive unit vocabulary means most measurements translate accurately.
• Instructions -- extracted from the RECIPE table. Multi-paragraph instructions are split into individual steps.
• Prep and cook times -- available both as raw minute counts and as human-readable strings. The parser uses whichever is available.
• Servings and yield -- directly from the RECIPE table.
• Source URLs -- if a recipe's instructions contain an embedded link (common for recipes imported from the web), the URL is extracted and preserved.

What Might Not Transfer

Images. Cook'n stores recipe images in its own format within the database or as separate files. The current parser focuses on the transaction log data, which contains the recipe text but not binary image data. If your Cook'n recipes have photos, those may not come through.

Categories and tags. Cook'n's organizational structure (cookbooks, chapters, categories) involves additional database tables that the parser does not currently map. Your recipes will export as a flat list rather than preserving the folder hierarchy.

Nutritional calculations. Cook'n has built-in nutritional analysis tied to its food database. This computed data does not appear in the recipe export since it depends on Cook'n's proprietary food-nutrient database.

Meal plans and shopping lists. These are application-specific features stored in separate database tables that are not part of the recipe extraction.

After Parsing: Your Export Options

Once MoveMyRecipes has extracted your Cook'n recipes, you can export to any of seven formats:

• JSON -- Schema.org-compliant, ready for import into modern recipe apps
• CSV -- for spreadsheets or database imports
• Markdown -- for note-taking apps or plain-text archives
• CookLang -- the open-source .cook format
• PDF -- formatted recipe cards
• HTML -- styled web pages
• Open Recipe Format -- YAML-based open standard

The original Cook'n data (descriptor and recipe table fields) is also preserved in the JSON export as a custom field, so if you ever need to reference the raw data, it is there.

A Note on Cook'n Versions

Cook'n has gone through many versions since 1994, and the file format has evolved. The MoveMyRecipes parser targets the HSQLDB-based format used by Cook'n 10 and later versions. If you have very old Cook'n files from earlier versions, the format may differ and the parser may not be able to read them. For most users with relatively recent versions, the .ckn format should work.

Getting Started

If you have a .ckn file -- either exported from Cook'n or from a backup -- head to movemyrecipes.com/cookn. Upload the file, let the parser work through the database, and pick your export formats. The process is free, requires no account, and your files are automatically deleted after seven days.

Thirty years is a long time to keep recipes in one place. It is worth having them in a format that does not depend on any single application to remain usable.