Synthetic Data Generator: A Python Framework for Tabular Data with LLM and GAN Models

What SDG is for and who needs it

SDG addresses a specific pain: generating structured tabular data that mimics an original dataset without exposing sensitive information. The README claims synthetic data retains essential characteristics while being exempt from privacy regulations such as GDPR and ADPPA, though that is a legal claim you should not take at face value. The intended users are engineers and data scientists who need to share data, train models, debug systems, or test applications without using real records. The framework is not a general-purpose data augmentation tool; it is specialized for tables, meaning rows and columns with types like integers, floats, categories, and datetimes. If your data is unstructured text or images, this is the wrong tool. The project targets Python users who are comfortable with model selection and metadata configuration.

The architecture: models, data processor, and metadata

The repository layout reveals three core components. The data processor converts column formats before they enter a model, and reverses the conversion on generated output. For example, datetime columns can be transformed so they are not treated as discrete categories, and null values can be handled. The data models metadata module describes single or multiple tables, supports multiple data types, and can infer types automatically. The models module contains different generators: a CTGAN variant that handles billions of rows, a GaussianCopula model, and an LLM-based single-table model that can generate data without any training data. Each model plugs into the same processor and metadata pipeline. This separation means you can switch between a GAN, a statistical copula, or an LLM without rewriting data preparation logic. The processor also supports a plug-in system for custom pre- and post-processing, which is useful when you have domain-specific transformations.

Getting started: commands and configuration from the README

The README does not include explicit installation commands like pip install sdgx, but the Python package name shown in the PyPI badge is sdgx, so a typical install would be pip install sdgx. The documentation is hosted on Read the Docs, and the README points to Colab examples for specific models. The core workflow involves creating a metadata object, which can be inferred automatically or specified manually. You then select a model, such as sdgx.models.LLM.single_table.gpt.SingleTableGPTModel, and fit it to your data or, for the no-data case, to metadata alone. The data processor is configured to handle column types; the README notes that datetime columns should be converted before feeding to avoid being treated as discrete types. There is no command-line interface mentioned; this is a library you use from Python scripts. The release history shows version 0.2.4 from December 2024, so you should pin to that version for stability.

The LLM model: synthesis without training data

One of the most distinctive features is the LLM-based single-table model, which can generate synthetic data based only on metadata, meaning no training records are required. The README calls this 'Synthetic data generation without Data'. This is a departure from GAN or statistical methods that need an original table to learn distributions from. The model also supports what the README calls 'off-table feature inference', which suggests it can infer values for columns that are not present in the training table, a capability traditional models lack. However, the README does not specify which LLM is used, how it is invoked, or whether it requires an API key or local model weights. This is a significant gap for adoption. The Colab examples suggest it works in a hosted notebook environment, but you should check the API documentation for the exact parameters. The trade-off is that LLM generation may be slower and costlier than CTGAN or GaussianCopula, and the output quality depends on the underlying model's ability to understand table schemas.

Performance claims and the billion-row CTGAN

The README makes a concrete performance claim: the CTGAN model supports 'billion-level data processing' and, in a benchmark against SDV, achieved less memory consumption and avoided crashing during training. The benchmark results are linked from the repository's benchmarks directory. The news from November 2024 states that GaussianCopula's memory usage was reduced when handling discrete data, enabling training on thousands of categorical entries with a '2C4G' setup, which likely means 2 CPUs and 4 GB of RAM. These are specific and testable claims, but you should not take them as universal. The memory improvements likely come from streaming or chunked processing, but the README does not describe the mechanism. If your dataset is in the millions of rows, you may need to verify that your chosen model can handle it within your own memory limits. The billion-row figure is impressive but also a red flag that the implementation may be complex to configure correctly.

Limitations and wrong-tool cases

The README focuses on single-table synthesis. It mentions metadata for multiple tables, but the news and examples center on single-table models. If you need to generate a relational database with foreign keys and referential integrity, SDG may not be the right choice. The data processor handles null values and type conversions, but the README does not describe how it handles complex constraints like unique keys, check constraints, or business rules that span columns. The LLM model's no-data generation is intriguing, but it also raises a risk: without training data, the synthetic output may not reflect real-world correlations that are not explicit in the metadata. The README's privacy claims are also broad. Saying synthetic data is 'exempt from GDPR' is a legal determination that depends on how the data is generated and used. You should treat that as a marketing statement, not a guarantee. Finally, the project is relatively young, with the first commit in August 2023 and the latest release in December 2024, so the API may still be evolving.

Alternatives and how they differ

The README explicitly benchmarks against SDV, the Synthetic Data Vault. SDV is a well-known open-source library that offers multiple models including CTGAN, CopulaGAN, and GaussianCopula, but its architecture is heavier and the README claims SDG avoids crashing on large data. The key difference is that SDV is a broader platform with support for multi-table synthesis and a mature API, while SDG appears to be a leaner framework that targets scalability and LLM integration. Another alternative is the YData Synthetic package, but the README does not mention it. The practical difference is that SDV may be easier to start with because of its extensive documentation and community, but SDG's data processor and plug-in system give you more control over type handling. If you need multi-table support, SDV is likely a better fit. If you need to generate data from metadata alone, SDG's LLM model is a unique feature that SDV does not offer in the same way.

Maintenance, licensing, and upgrade considerations

The project is licensed under Apache-2.0, which is permissive and allows commercial use, modification, and redistribution, with the condition that you preserve copyright notices and state changes. This is a low-license-risk choice for most organizations. The repository shows active maintenance: the default branch is main, the last push was August 2026 (based on the given data), and there are recent releases in late 2024. The presence of CI tests, pre-commit hooks, and Read the Docs documentation indicates a structured development process. However, the release cadence is not regular: 0.2.2 and 0.2.3 came in November 2024, and 0.2.4 in December, but there is no guarantee of a consistent schedule. The README mentions a roadmap, but the details are not in the excerpt. Before upgrading from one minor version to another, you should review the changelog and test your pipelines, as the data processor and model APIs may change. The project also has a Slack and WeChat group, which suggests community support is available, but you should not rely on it for production SLAs.

Editorial conclusion

Adopt SDG if you need to generate tabular data from large datasets with limited memory, or if you want to synthesize rows solely from metadata without any training data. Do not adopt it if you require multi-table relational synthesis or production-grade privacy guarantees; the README focuses on single-table models and makes broad legal claims about GDPR and ADPPA exemptions that you must verify with counsel. Before using it, test the data processor with your column types, especially datetime and null values, and confirm the model you choose supports your data's cardinality. Verify the current release 0.2.4 works with your Python version and that the documentation covers your use case.

Official sources

1. hitsz-ids/synthetic-data-generator on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases