Skitten Program: Automated Translation Framework

• Skitten Program is a system for skeleton-based program translation that abstracts source code into high-level structures with annotated semantic requirements.
• It employs a two-phase process: rule-based mechanical skeleton translation followed by iterative fragment synthesis using dynamic execution profiling.
• Empirical results show ~95% automated translation of code fragments and 100% correctness in test suites, demonstrating its scalability for large codebases.

The Skitten Program is a systematic instantiation of skeleton-based automated program translation between programming languages, as described in "Program Skeletons for Automated Program Translation" (Wang et al., 10 Apr 2025). It addresses the challenge of converting software—specifically from Python to JavaScript—into functionally and idiomatically correct code in the target language by abstracting source programs into high-level skeletons with annotated semantic requirements. This decomposition enables scalable, sound, and partially automated translation, achieving high correctness and maintainability for large codebases.

1. Skeleton-Based Translation: Concept and Formalism

The program skeleton is an intermediate representation that preserves the top-level structure of the source program (lexical scopes, function signatures, class declarations), while abstracting away low-level implementation details. These details are replaced with placeholders, each annotated by a formal semantic requirement, typically expressed as input–output traces observable during execution.

Formally, a program skeleton can be notated as

$$\hat{K} = \langle K, \varphi_1, \varphi_2, \ldots, \varphi_n\rangle$$

where $K$ is the skeleton with holes $h_1, h_2, \ldots, h_n$, and each $\varphi_i$ is the observable behavior specification for $h_i$. The translation guarantees correctness when each fragment $g_i$ synthesized for hole $h_i$ satisfies its local specification:

$g_i \models \varphi_i$

If the above holds for all fragments, the composed target program will behave equivalently to the source, with respect to the test suite.

2. Translation Pipeline and the Skel System

Translation in the Skitten Program comprises two principal phases:

1. Skeleton Extraction and Mechanical Translation: The Skel system analyzes the Python source, generating a skeleton that retains function, class, and scope structure but abstracts specifics. Shared constructs between source and target languages (e.g., Python and JavaScript) enable rule-based mechanical translation of the skeleton itself.
2. Fragment Synthesis via Execution-Order Translation (EOT):

For each placeholder, Skel derives semantic requirements by dynamically profiling the source program under the “darkblue” model, representing fragments as communicating processes producing observable traces. The system then invokes LLM-driven synthesis (fragSynth), iteratively refining candidate code fragments in the target language using the EOT algorithm:

If gᵗᵍᵗ(Id) = Null then gᵗᵍᵗ(Id) ← fragSynth({Input, Output}, gˢʳᶜ(Id)) While (mismatch exists in trace comparison) do Spec(Id) ← Spec(Id) ∪ {mismatch} gᵗᵍᵗ(Id) ← fragSynth(Spec(Id), gˢʳᶜ(Id))

This iterative process continues until synthesized fragments exhibit execution traces consistent with expected behavior, ensuring semantic fidelity.

3. Scalability and Empirical Performance

Empirical evaluation of the Skel system demonstrates high scalability and automation:

Metric	Value	Context
Programs translated	9	Real-world Python programs
Largest program size	>1000 LOC
Fragments automatically translated	~95%	Functions/fragments
Fragments requiring manual fix	~5%	Functions/fragments
Final correctness	100% (passes all test suites)	Whole-program semantic tests

This suggests the approach is suitable for large-scale codebases and enables high levels of automation in program translation, minimizing required manual intervention.

4. Semantic Modeling and Type Mapping

Each fragment’s specification is formally extracted from dynamic traces—sequences of input–output messages. For example, a semantic requirement may take the form:

$$Init(\text{CTX}) \rightarrow Call(\text{ARGS}) \rightarrow Return(\text{VAL})$$

The Skitten Program utilizes a type mapping function $\mathcal{F}$ to ensure type-level correctness in translation:

$$\mathcal{F}(\text{Int}) = \text{Number} \ \mathcal{F}(\text{Str}) = \text{String} \ \mathcal{F}(\text{List}[\tau_1, \tau_2, \ldots, \tau_n]) = \text{Array}[\mathcal{F}(\tau_1), \mathcal{F}(\tau_2), \ldots, \mathcal{F}(\tau_n)]$$

These mappings systematically reproduce observable semantics in the target domain.

The EOT algorithm updates a counterexample set $\{\text{Spec}\}$ for each fragment, ensuring for all $e \in \{\text{Spec}\}$:

$$\forall e \in \text{Spec},\ \text{execute}(K \cup \{g^t\}) \equiv e$$

This compositional formalism underpins the soundness of translation.

5. Comparative Evaluation and Methodological Distinctions

Skitten Program’s partitioned translation approach offers structural advantages:

• Divide-and-Conquer Correctness:

Unlike LLM-only translation, which is prone to compounding errors across interdependent regions, skeleton-based decomposition localizes error detection and enables isolated refinement.

• Rule-Based vs. Skeleton-Based Systems:

Conventional rule-based transpilers often produce non-idiomatic or syntactically brittle outputs. Skel achieves idiomatic, maintainable code in the target language by separately handling skeletons and fragments—mechanically translating high-level structure and using guided synthesis for the details.

• Quantitative Improvement:

Evaluations indicate Skel matches or surpasses baseline systems in automation rate (~95%) and correctness (final programs pass all tests), with substantially reduced manual correction effort.

6. Implications for Automated Program Migration

The Skitten Program demonstrates that skeleton-based decomposition, combined with dynamic semantic profiling, enables automation of program translation at a scale and correctness previously unattainable with monolithic approaches. This suggests that future systems for code migration can benefit from leveraging high-level abstractions and iterative synthesis to both ensure maintainability and uphold functional semantics in the target language.

A plausible implication is that, provided suitable test coverage and semantic models, similar skeleton-based paradigm can generalize beyond Python–JavaScript translation to other language pairs in software migration projects, contingent on the availability of idiomatic mappings and execution profiling.