How do I convert a GitHub repo to a text file?

Paste the repository URL above and the file tree appears as a checkbox list. Untick what the model does not need, generate, and you get one text file: directory structure at the top, then each selected file under a header with its path. Nothing to clone, nothing to install, free and no sign-up.

How do I convert a private GitHub repository?

Paste a personal access token alongside the URL. Create a fine-grained token scoped to just that one repository with read-only Contents permission and a short expiry — that is the least privilege the API will accept for this. The token is used to call GitHub from your browser and is not stored on our side.

How many tokens is my codebase, and will it fit?

The counter updates as you tick files, so you can see the number before you paste anything. As a rough guide, source code runs around 3 to 4 characters per token, so a 500 KB selection lands near 140,000 tokens. That fits a 200K context window and will not fit into a single chat message on most interfaces.

Which files should I exclude before feeding a repo to an LLM?

node_modules, vendor, and any dependency directory first — they are usually the overwhelming majority of the bytes and contribute nothing about your code. Then lockfiles, build output, minified bundles, test fixtures, and binary assets. On a typical JavaScript project that pass alone often removes over ninety percent of the tokens.

How does this compare to gitingest, repomix, or code2prompt?

Those are strong tools and the honest difference is workflow, not capability. They are command-line first, scriptable, and the right answer inside CI or a batch job. This runs in a browser tab with a checkbox tree, so you can see the repo, deselect what you do not want, and watch the token count move — better for the one-off case where you are still deciding what to include.

Is it safe to put my code through this?

Public repositories are read through the GitHub API from your browser, so the code goes from GitHub to you. For anything confidential the stronger option is the local folder converter, which never uploads at all. Either way, scan your selection for API keys and credentials before pasting it into a model — that is the step people skip.

DIA 1.6: Open-Source Text-to-Speech Model Explained

Dia: Nari Labs’ 1.6B-Parameter Open-Source Text-to-Speech Model

Dia is the latest open-source text-to-speech (TTS) model from Nari Labs, a tiny startup. It’s a 1.6 billion-parameter neural model that can directly generate highly realistic dialogue from plain transcripts. In other words, you write a conversation script with speaker tags like [S1] and [S2] , and Dia produces an audio recording of the conversation – complete with tone, emotion, and even nonverbal sounds like laughs or coughs. This ability to inject personality and emotion into synthesized speech makes Dia stand out: its creators claim it surpasses commercial offerings like ElevenLabs Studio and even Google’s NotebookLM podcast feature in naturalness and expressiveness.

Why is Dia significant in the AI voice space? For one, it’s open-source (Apache 2.0 license) and free to use, unlike many high-quality TTS systems locked behind paid APIs. Any developer can download Dia’s weights from GitHub or Hugging Face and run it on consumer-grade hardware (with about 10 GB of GPU memory). It was trained on conversation transcripts, so it natively handles multi-speaker dialogue. And because it’s released now (April 2025), it reflects cutting-edge research: Dia’s design was inspired by Google’s SoundStorm and Parakeet models and uses the Descript Audio Codec for high-fidelity output. In short, Dia brings a state-of-the-art neural speech synthesis engine for dialogue into the hands of the AI community, ready for experimentation and integration.

Dia’s Architecture and Capabilities

Under the hood, Dia uses a transformer-based sequence model similar to modern speech synthesis systems. It contains about 1.61B parameters , which is quite large for an open model but smaller than proprietary engines. Dia’s architecture draws on Google’s SoundStorm (a fast audio generator) and Parakeet (a TTS seq2seq model). Essentially, Dia takes a scripted text (with speakers labeled [S1] , [S2] ) and predicts a sequence of high-level audio tokens. These tokens are then decoded into actual sound waves using the Descript Audio Codec – a pretrained neural codec that efficiently converts tokens to waveform. This pipeline lets Dia produce realistic prosody (rhythm and intonation) and dialogue timing that feels natural.

Several key capabilities emerge from this design:

Multi-Speaker Dialogue: Dia expects alternating speaker tags ( [S1] , [S2] , etc.). It can generate an entire conversation in one pass, switching voices between speakers. The model wasn’t trained on a single fixed voice, so each run can result in different speaking voices. To maintain a consistent speaker, users can set a fixed random seed or provide a short audio example of the target voice – the latter method effectively “clones” a voice. For example, one can upload a sample in the Hugging Face Space or use the example/voice_clone.py script to tell Dia: “Use this voice sample for the upcoming dialogue.”
Emotion and Tone Control: By feeding it an audio prompt (e.g. a few seconds of happy or angry speech) or through script cues (like punctuation and context), Dia can modulate the emotional tone of its output. It has built-in support for nonverbal sound effects too – tags like (laughs) , (coughs) , (sighs) , etc. in the text will produce those sounds in the audio. These features let Dia move beyond flat robot voices to something closer to human conversational speech with realistic pauses and filler sounds.
Performance and Hardware: Dia is computationally heavy but optimized. On a recent GPU like an NVIDIA A4000, Dia generates around 40 tokens per second (86 tokens ≈ 1 second of audio). In practice that means roughly real-time or slightly slower performance for speaking-speed dialogue. The full model needs ~10 GB VRAM to load, so it runs on most modern gaming/workstation GPUs. (The team plans to release a quantized version to reduce memory needs.) Notably, Nari Labs says Dia can run on consumer hardware; in fact they mention “consumer-grade GPUs with about 10GB of VRAM” are sufficient. If you lack a GPU, you can also try Dia in an online Hugging Face Space without installing anything.
Current Language Support: English-only (for now). Dia was trained on English dialogue datasets, and its model card explicitly notes it “only supports English generation at the moment.” . This is important: unlike some other TTS engines, Dia won’t yet speak French or Chinese out of the box. However, nothing in the architecture inherently forbids multilingual use. In the future, Nari Labs or the community could fine-tune Dia on other languages. But at launch, think of Dia as a conversational English voice generator.
Fine-Tuning and Voice Cloning: The base Dia model has not been fine-tuned for any single accent or speaker, hence it produces varied voices by default. The repo includes tools for voice cloning : by supplying a short audio example and its transcript, Dia will attempt to adopt that vocal style for the rest of the conversation. This is still experimental (“guide coming soon”), but it shows that Dia can be adapted. In short, you don’t need Dia to be pre-trained on a celebrity voice – you can teach it one by example.

In summary, Dia’s architecture combines modern TTS research (parallel audio generation, neural codecs) with conversation-focused training. It excels at dialogue synthesis : if you want to simulate a back-and-forth chat or a scripted exchange, Dia gives you full control over the conversation flow, speaker turns, and emotional cues. Underlying all this is the transformer-like model of 1.6B parameters, which is sufficiently large to capture a wide range of speaking styles without being insanely huge.

Running Dia: Setup and Code Examples

Getting started with Dia is straightforward for developers. The code is hosted on GitHub at nari-labs/dia and on Hugging Face at HuggingFace.co/nari-labs/Dia-1.6B . You can install and run it either locally or via provided demos.

Install via pip (from GitHub): The simplest way is to clone or pip-install the repo. For example:
```
pip install git+https://github.com/nari-labs/dia.git
```
This grabs the latest code. (As of writing, the Dia model itself is not on PyPI; you install straight from GitHub.) You may need additional packages like soundfile for saving audio, and the instructions on the GitHub page show how to set up a virtual environment and install dependencies.
Gradio Demo UI: The repository includes a simple Gradio app ( app.py ) for interacting with Dia in your browser. After installing, you can run:
```
git clone https://github.com/nari-labs/dia.git
cd dia
uvicorn app:app --reload
```
(Or just run python app.py after activating the venv, as shown on GitHub.) This launches a local web UI where you can type dialogue scripts and hear the results without writing code.
Using Dia as a Python Library: For programmatic use, import the model and generate audio like in the example below. The model is available through the Hugging Face hub, so you can load it with Dia.from_pretrained("nari-labs/Dia-1.6B") . For example:
```
import soundfile as sf
from dia.model import Dia

# Load the Dia model from Hugging Face
model = Dia.from_pretrained("nari-labs/Dia-1.6B")

# Prepare a simple dialogue script
text = "[S1] Hey, how’s the weather today? [S2] Sunny with a chance of code!"

# Generate audio waveform (as a NumPy array of float32 samples)
audio = model.generate(text)

# Save the output to an audio file
sf.write("dia_output.wav", audio, 44100)
```
This snippet (adapted from the official docs) shows how brief it is to use Dia. The generate() function takes your full script (with speaker tags and optional stage directions like (laughs) ) and returns a waveform. You can then play it, save it, or process it further.
Hugging Face Spaces: Nari Labs also provided a hosted demo on Hugging Face Spaces (zero-GPU grant). You can try Dia without any setup at the link on the model page. This is a quick way to experiment: just type your conversation and listen. The Space even includes an example of voice cloning : upload a sample of speech and it will clone that voice in the output.
Hardware Requirements: Note that running Dia locally needs a decent GPU. The model card reports that Dia can run in real time on enterprise GPUs, but requires about 10 GB VRAM for the full model. On an older or lower-memory GPU, you might use a smaller quantized version once it’s released, or try streaming inference. For CPU-only machines, performance would be very slow (Dia was primarily tested on GPUs).

If you want a quick start guide, the official GitHub README walks through these steps, or check out the Hugging Face model card for Dia which mirrors the docs. In short, running Dia is as easy as pulling from GitHub or Hugging Face and calling model.generate(text) in Python (or using the provided CLI/Gradio scripts).

Comparing Open-Source TTS Models: Bark, Tortoise, Coqui, and Dia

Dia isn’t the only open-source text-to-speech model around. Other community projects like Suno’s Bark , Tortoise TTS , and Coqui TTS offer different trade-offs. Here’s how Dia stacks up against these well-known alternatives:

Bark (Suno) – Bark is a text-to-audio model that supports multilingual speech (about 13 languages) and can even generate other audio (music, sound effects) alongside voice. It’s also a transformer-based model, and open-sourced under an MIT license. Bark’s strengths are flexibility and language coverage: it can speak in many languages and do non-speech audio. However, it is less specifically tuned for dialogue flow. Bark’s outputs can be expressive (it includes nonverbal cues like laughing, crying), but some users find Bark’s speech timing and accuracy less consistent than Dia’s dialogue focus. In short, Bark is versatile and multilingual , whereas Dia is optimized for natural conversational English . If you need a TTS that handles multiple languages or even generates background sounds, Bark might be a better fit. If you want a tight multi-turn conversation with emotional nuance, Dia has the edge.
Tortoise TTS – Tortoise (by neonbjb) emphasizes voice quality and cloning . It’s known for exceptionally lifelike prosody and intonation. Tortoise can mimic specific voices (with relatively little reference data) and switch between them. Its creators joke that it’s “insanely slow” – the name is not a misnomer. In early versions, generating even a medium sentence on a single GPU could take minutes. Fortunately, recent improvements (integration with DeepSpeed and streaming) have boosted its speed dramatically (e.g. RTF ~0.25 on a 4GB GPU). Even so, Tortoise is computationally heavy compared to Dia. Users report that a single run of Tortoise can still be slower than real time, whereas Dia on a modern GPU can run at conversational speed. The trade-off is that Tortoise’s static voices can sound exceptionally natural and varied. Dia’s voices are also high-quality, but Tortoise has a slight quality edge and more built-in voice-cloning. On the other hand, Dia has built-in support for dialogue structure and is somewhat faster.
Coqui TTS – Coqui is actually a toolkit (formerly Mozilla TTS) rather than a single model, but it’s widely used as open-source TTS. Coqui provides many pretrained voices and supports over 1,100 languages through various models. It also integrates modern neural vocoders (like HiFi-GAN) for fast audio synthesis. Coqui’s focus is on speed and flexibility: its typical models can run near real-time on consumer hardware, even CPU-only, and it has tools for training and fine-tuning new voices in any language. In terms of quality, Coqui voices are generally quite good – often comparable to Bark’s output – and users can choose voices for different styles. Dia differs from Coqui in that Dia is a single end-to-end model pretrained for dialogue, whereas Coqui expects you to pick or train specific voices. Coqui’s strength is breadth (many languages, easy training), while Dia’s strength is specialized dialogue generation with emotional nuance. If you need a quick text-to-speech in many languages, Coqui is a go-to; if you want a conversational English AI voice, Dia leads.

Below is a quick summary of the trade-offs:

Language Support: Bark (13 langs), Coqui (1100+ via models) > Dia (English only) and Tortoise (primarily English).
Voice & Prosody: Tortoise (top), Dia (strong in dialogic flow), Bark/Coqui (good, but more generic).
Speed: Coqui/Bark (fast on CPU/GPU), Dia (moderate on GPU), Tortoise (slow unless optimized).
Special Features: Bark (audio generation beyond speech), Dia (dialogue & nonverbal cues), Tortoise (voice cloning), Coqui (training/fine-tuning toolkit).
Licenses: Bark is MIT, Coqui MPL-2.0, Tortoise/Dia are Apache 2.0 (all allow commercial use).

Each model has its niche. Dia’s niche is conversational, multi-person dialogue with emotion and timing, powered by an open-source AI voice model . For example, Dia will properly pause when one speaker interrupts another or maintain a natural back-and-forth pace, which some other models might not handle as gracefully.

In contrast, if your project is multilingual TTS or extreme voice cloning, you might lean Bark or Tortoise. If you’re building a large-scale product in many languages, Coqui’s library is very helpful. But for a startup or hobbyist demo of realistic conversation AI , Dia is a compelling new option.

Developer Tools and Resources

Working with these AI models often involves code repositories, data crawling, and various AI utilities. Here are some handy tools and resources (including our own) that can streamline your workflow:

Convert GitHub Repos to Text: When analyzing or training on code/data, you might want the raw text of a repository. The repo2txt service converts a GitHub repository into plain text files for easy reading by LLMs or text processors. For instance, to feed Dia a large script stored on GitHub, you could use repo2txt to dump that repo’s contents into text form. You can also run a local version via convert GitHub repo to text (repo-to-text) for secure offline use. These tools support keywords like “repo to text” and “github repo to text online,” making it simple to prepare code or transcripts for AI models.
Data Crawling for AI: If you need to gather large amounts of code or text data from the web, check out crawl4ai . It’s designed to crawl websites and GitHub for code snippets, documentation, and more, feeding them into your AI pipelines. This can help build training corpora or gather domain-specific examples (e.g. public dialogues or scripts).
ITS IT Group (AI/ML & Dev Services): For businesses or teams looking for professional support, ITS IT Group offers services in AI/ML development, web development, app development, and DevOps . Whether you need help deploying Dia at scale, integrating TTS into an application, or any custom AI consultancy, their team can assist. (This blog is not commercialized, but it’s worth noting if you need a partner for AI projects.)
Community and Forums: Join Nari Labs’ Discord server for discussions about Dia, tips on TTS, and announcements of new features. GitHub Discussions or issues on the Dia repo can also be a good place to ask technical questions.

By combining Dia with these tools, you can streamline your AI voice projects: use repo-to-text conversion to turn scripted dialogues into training data, employ crawl4ai to collect background corpora, and rely on proven platforms like ITS IT Group for integration and scaling. This ecosystem approach – pulling together open-source models and dev tools – makes it easier than ever to build sophisticated AI voice applications.

Conclusion and Call-to-Action

Dia is an exciting advance in the open-source TTS landscape. With its 1.6B-parameter dialogue generation model, emotion control, and speaker tagging, it can produce conversation audio that feels startlingly human. It fills a niche that competitors haven’t fully addressed: multi-turn, emotional speech synthesis, released under a permissive license.

If you’re curious, give Dia a try! Visit the Nari Labs GitHub repo or Hugging Face model card to download the model. Spin up the Gradio demo or plug the code snippet above into your Python environment. Experiment with different scripts, tones, and speaker arrangements.

As you explore, remember that you have a suite of tools at your disposal. Use repo2txt.com to convert any project repository to text (ideal for feeding scripts to Dia or any LLM). Check out the convert GitHub repo to text feature for offline use. Consider crawl4ai if you want to aggregate data from the web. And if your venture needs professional help – whether it’s AI/ML integration, building web or mobile apps around Dia, or DevOps pipelines to serve voice models – ITS IT Group offers services in exactly those areas (AI/ML, Web Dev, App Dev, DevOps).

In summary: Dia brings next-generation conversational voice synthesis to the public. Dive in and see what it can do for your projects. Generate some dialogue, compare voices, and don’t forget to leverage the handy tools and services linked above. Happy coding, and happy voice generating!

Sources: We’ve cited details from Nari Labs’ official GitHub and Hugging Face pages, as well as news coverage and documentation from Bark and Coqui, to ensure this overview is accurate and up to date.