Maple

Built around practical full-stack work.

Samples span Next.js, React, Remix, SvelteKit, Astro, Vue, Tailwind CSS, and TypeScript. They cover dashboards, admin panels, content-management systems, browser games, interactive prototypes, authentication, forms, mock APIs, server actions, and structured application logic.

Each row contains a unique query_ID, a user-facing input, and an output with implementation details, explanation, and code.

A broad cross-section of modern product engineering.

Maple concentrates on high-signal software-building requests rather than narrow algorithm exercises. Many samples describe a complete product surface with layout, state, validation, navigation, responsive behaviour, accessibility, error handling, and maintainable component structure.

Loading, empty, validation, error, and edge-case states are represented alongside desktop and mobile requirements. The goal is to capture the decisions involved in shipping a complete experience, not merely producing syntactically plausible code.

Generated locally with a modern open inference stack.

Maple was generated using Qwen3.5-122B-A10B through llama.cpp, accelerated by AMD ROCm 7.0.0 on an AMD Ryzen AI Max+ 395 system. The process targeted detailed instruction-response pairs with realistic product requirements and substantial implementations.

Validated for structure, identity, and completeness.

The released Parquet file was curated to contain non-empty instruction-response pairs with unique query identifiers. Basic validation checks confirmed that all 16,000 rows load successfully and that the three required string columns are consistently present.

Structural validation is not the same as functional verification. Users should apply their own filtering for correctness, security, formatting, licensing compatibility, and the behavioural goals of the target model.

Load from Hugging Face or local Parquet.

from datasets import load_dataset

dataset = load_dataset("tudor-iustin22/maple")
print(dataset["train"][0])

Maple is intended for supervised fine-tuning, post-training, instruction tuning, code-generation research, evaluation, developer tooling, and commercial or open-source model development with attribution.

Transform Maple for the model and chat template you use.

The source rows are deliberately simple: one instruction and one generated response. A basic instruction-tuning transformation can combine them into a single text field before tokenisation.

from datasets import load_dataset

dataset = load_dataset("tudor-iustin22/maple", split="train")

def format_sample(sample):
    return {
        "text": (
            "### Instruction\n"
            f"{sample['input']}\n\n"
            "### Response\n"
            f"{sample['output']}"
        )
    }

formatted_dataset = dataset.map(format_sample)

Downstream users should adapt separators, roles, special tokens, and loss masking to the tokenizer and chat template of the target model. Response formatting may also benefit from additional cleanup before supervised fine-tuning.

Open for research and commercial work—with attribution.

Maple is released under Creative Commons Attribution 4.0 International. It may be used, shared, redistributed, adapted, modified, and used commercially, provided that Tudor Iustin is credited as the dataset’s developer, owner, and releaser.

“This work uses Maple, an open-source full-stack code dataset developed and released by Tudor Iustin.”

Intended applications include supervised fine-tuning, post-training, coding-assistant development, full-stack generation research, software-engineering evaluation, synthetic-data research, benchmarking, and commercial or open-source model development.

Maple should not be used to build systems intended to generate malware, steal credentials, gain unauthorised access, bypass security controls, violate licences or intellectual property, remove attribution, or claim Tudor Iustin’s endorsement of a downstream product.

Synthetic data still requires judgment.

Generated responses may include software bugs, insecure patterns, outdated dependencies, incomplete assumptions, hallucinated packages or functions, accessibility issues, inefficient architecture, or code that requires additional configuration. Not every generated project is guaranteed to compile, execute, or satisfy every stated requirement without modification.

Performance will vary with the downstream model, tokenizer, chat template, training configuration, formatting, filtering, and evaluation process. Before deploying generated code, users should review functional correctness, dependency safety, privacy, accessibility, licensing, and operational reliability.

Maple is an independent dataset resource and is not endorsed by or affiliated with Qwen, AMD, llama.cpp, or any downstream model trained using it. References to hardware and software identify the creation environment only.