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.

Qwen3 LLM: Overview of the Next-Generation Language Model

Introducing Qwen3 LLM: Architecture, Training, and Key Features

The Qwen3 series is the latest open-source large language model (LLM) family released by the Qwen team at Alibaba Cloud . Qwen3 builds on the previous Qwen2.5 and QwQ models, offering a range of dense and Mixture-of-Experts (MoE) models from 0.6B up to 235B total parameters. Notably, the flagship Qwen3-235B-A22B (235B total, 22B active) delivers performance in coding, math, and general reasoning on par with the biggest models in the industry . All released Qwen3 models (dense and MoE) are open-weight under the Apache 2.0 license , meaning developers and researchers can use and fine-tune them freely. In this article, we will dive deep into Qwen3’s architecture, its novel training approach, and its standout features. We will then compare the Qwen3-32B dense model against the QwQ-32B reasoning model, focusing on benchmarks, data, context support, fine-tuning, and inference. Along the way, we’ll link to useful resources like repo2txt (for converting GitHub repos to text) and highlight how experts such as Its IT Group can help organizations deploy these advanced LLMs.

Qwen3 Architecture and Model Variants

Qwen3 is built on a transformer decoder backbone with several modern enhancements. The models use RoPE positional embeddings, SwiGLU feedforward layers, and RMSNorm, similar to prior Qwen designs . Notably, Qwen3 employs GQA (Group Query Attention) : each layer uses many more query heads than key/value heads (e.g. 64 Q-heads vs 8 KV-heads for the 32B model) . This asymmetric attention can improve efficiency. Each dense model has token embeddings tied to the output layer (except larger ones where it is disabled) . Qwen3 comes in seven dense sizes (0.6B, 1.7B, 4B, 8B, 14B, 32B parameters) and two MoE sizes (30B total with 3B active, and 235B total with 22B active) . For example, Qwen3-32B has 64 layers, 64 Q-heads / 8 KV-heads, and 32 768 token context (131 072 with YaRN) . The MoE models (e.g. Qwen3-30B-A3B) split each layer into 128 experts, activating only 8 experts per token .

Context length is a highlight: Qwen3 models natively handle 32K tokens, and with the YaRN mechanism they can process up to ~131K tokens . This extreme context support means Qwen3 can handle long documents, codebases, or multi-turn chats without truncation. (For comparison, QwQ-32B also supports a full 131 072 tokens of context .) Overall, Qwen3’s architecture is optimized for both depth (many layers/heads) and scale (huge MoE) , while also enabling flexible long-context usage.

Training Qwen3: Data and Methods

Qwen3’s training regimen is a major step up from earlier models. In pretraining , the Qwen team roughly doubled the data compared to Qwen2.5. While Qwen2.5 used ~18 trillion tokens, Qwen3 was trained on about 36 trillion tokens spanning 119 languages and dialects . Data sources include web crawl text, academic PDFs (text extracted with Qwen2.5-VL vision model), and synthetic expansions. For instance, Qwen2.5-Math and Qwen2.5-Coder were used to generate extra math problems, textbook excerpts, question–answer pairs, and code snippets . This helped enrich the model’s STEM, coding, and reasoning knowledge.

Pretraining was done in three stages . In Stage 1, Qwen3 ran on ~30T tokens with a 4K-token context to build basic language understanding. Stage 2 added 5T more tokens, focusing on knowledge-intensive content (e.g. science, math, code) to bolster problem-solving skills. Finally, Stage 3 introduced long-context data : high-quality documents that enabled the model to support 32K token inputs. By the end, Qwen3 had both broad knowledge and long-context fluency. Thanks to architecture improvements and data, even Qwen3’s smaller models match or exceed previous large models: e.g. a 4B-parameter Qwen3 base model performs similarly to a 14B-parameter Qwen2.5 model . In fact, the Qwen team notes Qwen3 base models outperform larger Qwen2.5 baselines on STEM, coding, and logical reasoning .

After pretraining, Qwen3 underwent a multi-stage fine-tuning (post-training) pipeline . The goal was to create a hybrid “thinking” model that can reason step-by-step or answer directly. There are four post-training stages. First, the model is tuned on long chain-of-thought (CoT) examples (math problems, coding tasks, logic puzzles) to instill explicit reasoning skills . Next, reinforcement learning (RL) is applied, first focusing on math and code (using a math verifier and code-execution tests as rewards) . Then a “thinking-mode fusion” stage mixes those long-CoT examples with regular instructions, teaching the model both thorough reasoning and normal chat. Finally, a general RL phase uses a broad reward model and rule-based checks across ~20 tasks (including instruction-following and agent tasks) . This entire process yields a model that can toggle between deep reasoning and quick response (discussed below) while also aligning to human preferences.

Key Features of Qwen3

Qwen3 brings several standout capabilities:

Hybrid Thinking Modes. Each Qwen3 model can operate in two modes. In Thinking Mode , the model pauses to reason step-by-step (a chain-of-thought) before answering, ideal for complex problems . In Non-Thinking Mode , it answers instantly for simpler queries. Users can toggle these modes (or use enable_thinking flags in code) to adjust how much reasoning the model does. This flexible approach “allows users to control how much ‘thinking’ the model performs based on the task” . Hard problems get deeper reasoning; easy ones get fast answers. The result is a smooth trade-off between inference cost and answer quality, since more compute yields better results in thinking mode .
Multilingual Support. Qwen3 natively handles 119 languages and dialects , covering virtually all major world languages (from English and Chinese to Thai, Yoruba, and Icelandic). This extensive coverage makes Qwen3 suitable for international applications, multilingual chatbots, and translation tasks.
Agentic Capabilities. Qwen3 is engineered for agentic tasks – interacting with tools, code, or external environments. The models were fine-tuned on “multiple chain of thought problems” and tested on agent benchmarks . In practice, Qwen3 can write code that calls external APIs, plan multi-step workflows, or integrate with plugins. Combined with its thinking mode, Qwen3 achieves leading open-source performance on complex agent-based tasks .
Large Context Handling. Thanks to its three-stage training, Qwen3 processes very long inputs. Out of the box it handles 32K tokens, and with YaRN up to ~128K (131072) tokens . This is far beyond most models. Such large context is crucial for tasks like summarizing long documents, analyzing codebases, or having extended multi-turn conversations. Developers can use Qwen3 via frameworks like HuggingFace Transformers or vLLM to stream or batch-process high-token workloads.
Strong Instruction Following and Alignment. After training, Qwen3 exhibits excellent alignment to human instructions . It generates creative, coherent text for stories, dialogues, coding tasks, and more. Its output feels more engaging and natural compared to earlier models. This “superior human preference alignment” means Qwen3 can handle multi-turn dialogues, role-play, and creative prompts with flair .
Open-Source Licensing. Importantly for practitioners, Qwen3 is fully open-source under Apache 2.0 . You can download the weights (on HuggingFace, ModelScope, Kaggle, etc.), inspect them, and fine-tune them on your own datasets. The Qwen team also provides tools and docs (e.g. llama.cpp, Ollama, Transformers) to run Qwen3 locally or in production . This permissive license and tooling democratizes Qwen3 for all developers.

Performance Benchmarks

Qwen3 sets a new bar for open models. According to the Qwen team, Qwen3-235B-A22B matches or exceeds leading proprietary and open models on benchmarks. In coding, math, and general reasoning tests, it is competitive with top-tier models like DeepSeek-R1 (671B) , OpenAI’s o1/o3-mini , Grok-3 , and Gemini-2.5-Pro . Impressively, even the smaller MoE model Qwen3-30B-A3B (with only 3B active parameters) outperforms the QwQ-32B model – despite QwQ having roughly 10× more “activated” weights. And a tiny Qwen3-4B model rivals the much larger Qwen2.5-72B model . In other words, Qwen3’s architectural and training improvements make it far more efficient: less compute is needed for the same result.

Although detailed numbers vary by task, one chart (see below) highlights QwQ-32B’s results compared to large baselines. In this evaluation, QwQ-32B (red) scores almost as high as DeepSeek-R1 (blue) across five reasoning benchmarks: AIME24 (math contest problems), LiveCodeBench (coding), LiveBench, IFEval (instruction following), and BFCL (tool/function-calling). This reflects QwQ’s specialized focus. Qwen3’s performance isn’t shown here, but by the Qwen team’s account, Qwen3 models meet or exceed these levels even in general mode .

( QwQ-32B: Embracing the Power of Reinforcement Learning | Qwen ) Figure: QwQ-32B (red) vs. other models on reasoning benchmarks .

Another published result notes that Qwen3 base models outperform larger Qwen2.5 baselines in STEM, coding, and reasoning . Given that QwQ is built on Qwen2.5, this implies Qwen3 is at least on par or better in many areas. In human preference tests, Qwen3 also shows stronger creative and conversational ability than Qwen2.5. In sum, Qwen3 offers top-tier benchmark scores while remaining open-source.

Licensing and Accessibility

As noted, Qwen3 is released under Apache 2.0 , making it fully open for commercial and research use. All model weights and code are publicly available. You can try Qwen3 immediately in various ways: through the Qwen Chat web/mobile app or via the HuggingFace and ModelScope repos . Integration is straightforward. For example, the HuggingFace Transformers library supports Qwen3 out of the box – just AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-8B") , and you’re running. The documentation recommends tools like SGLang or vLLM for scalable serving, and local tools like Ollama or llama.cpp for single-machine usage .

Thanks to the Apache license, companies and developers can build commercial applications with Qwen3 without additional fees. If you need enterprise support, teams like Its IT Group – who specialize in AI/ML consulting, web and app development, DevOps and more – can help integrate Qwen3 into your products and infrastructure. Its IT Group, for instance, highlights AI/ML, LLMs, and cloud-native development as core competencies .

Use Cases and Deployment

What can Qwen3 actually do in practice? Its versatility makes it fit for many scenarios:

Chatbots and Assistants. With its strong conversational skills and mode-switching, Qwen3 can power advanced chat agents. For example, in helpdesk or tutoring bots, easier questions can get fast non-thinking replies, while complex inquiries trigger the model’s reasoning mode. Multi-turn dialogues, creative role-play, and contextful chats are all improved.
Coding and Data Analysis. Qwen3’s prowess in code generation and understanding (thanks to code in training) makes it a great coding assistant. It can write code snippets, debug, or explain algorithms. It also handles math problems and data analysis queries (chain-of-thought mode is handy for showing work). Developers preparing code-related training data could use a tool like repo2txt to scrape GitHub repositories into a plain-text corpus . In fact, Repo2Txt is designed to “convert GitHub repository … contents into a formatted text file for LLM prompts” , which is ideal for fine-tuning or prompting code-savvy models. If you prefer to work offline, the Local Directory to Plain Text converter does the same for local files .
Information Retrieval and RAG. Thanks to its broad knowledge base, Qwen3 can serve as the language component in retrieval-augmented generation (RAG) systems. It can synthesize answers from documents, perform multilingual retrieval, or even integrate tools (via function calling) for dynamic responses. This fits well with enterprise AI deployments (with pipeline orchestrators and DevOps support).
Multilingual Applications. With 119-language coverage, Qwen3 can handle translation, cross-lingual search, and international customer support chatbots out of the box. Even low-resource language tasks benefit from its training.
Creative and Content Generation. Qwen3’s alignment to human style means it can write articles, stories, or marketing copy convincingly. Teams in web development or app dev can use it for content prototyping or as a co-writer.
Agents and Tools. Lastly, Qwen3’s agentic capabilities shine in building software agents . It can plan multi-step workflows, call APIs, and reason through tasks. For instance, an AI system could use Qwen3 to dynamically generate code that interfaces with a database or to automate cloud infrastructure (DevOps), guided by our instructions and thinking mode. Firms specializing in AI/ML and DevOps (like Its IT Group) can customize Qwen3 as the brain of such automation.

In short, Qwen3 is designed for any application that benefits from powerful reasoning and conversation – from academic research to enterprise chatbots to software development tools.

Qwen3-32B vs. QwQ-32B: A Detailed Comparison

Now let’s compare Qwen3-32B (a general-purpose open model) with QwQ-32B (a specialized reasoning model from Qwen2.5). We’ll cover performance, training data, context, fine-tuning, and inference.

Purpose and Design: Qwen3-32B is a post-trained (instruction-tuned) model optimized for versatility. It supports both thinking and non-thinking modes and is fine-tuned on a wide range of tasks. By contrast, QwQ-32B is explicitly a reasoning model: it started from Qwen2.5-32B and was fine-tuned with heavy reinforcement learning to excel on math and logic tasks . In other words, QwQ-32B is the “expert thinker” version of the 32B model, while Qwen3-32B is the “all-rounder” version.
Performance on Benchmarks: On reasoning benchmarks, QwQ-32B achieves state-of-the-art scores among moderate-sized models. For example, it matches or slightly surpasses much larger models (like DeepSeek-R1) on tasks such as AIME24, IFEval, and BFCL . The chart above illustrates this: QwQ-32B’s scores (red) are nearly tied with DeepSeek-R1-671B (blue) across several tests. Qwen3-32B’s performance hasn’t been shown on those exact charts, but based on Qwen3’s reported results, it is generally competitive. Remember that the Qwen team stated a Qwen3 MoE model (30B-A3B) outperformed QwQ-32B even though QwQ had 10× more active parameters . While that MoE result doesn’t directly show the 32B dense model, it suggests Qwen3’s underlying model is very strong. In practical terms, for math/coding, QwQ-32B might edge out Qwen3-32B on very hard tasks due to its RL fine-tuning. But on general tasks and multilingual tasks, Qwen3-32B will likely hold the advantage.
Training Data Quality and Diversity: QwQ-32B was built on the Qwen2.5-32B pretraining (18T tokens, multi-domain) and then heavily augmented via RL on specific domains (math, code, then general tasks) . Qwen3-32B, however, was pretrained on 36T tokens covering 119 languages and included synthetic code and math data. So Qwen3-32B benefits from double the base data and more diversity. This likely gives it broader general knowledge. In addition, Qwen3’s long-context stage means its training included lengthy documents, which might not have been the case for Qwen2.5. Conversely, QwQ’s RL fine-tuning gave it very high-quality reasoning ability. In summary: Qwen3-32B trades off some specialized RL optimization for vastly larger and richer data, making it more knowledgeable overall, while QwQ-32B’s data pipeline was more focused (and enhanced by reward feedback).
Context Length: Both models support huge contexts (~128K tokens). Qwen3-32B natively takes 32K (131K with Yarn) , while QwQ-32B is built for 131,072 tokens (with YaRN beyond 8K) . In practice, this means either model can handle similarly large inputs. There’s no clear winner here; both are top-of-class for long-document tasks.
Fine-Tuning and Adaptability: Both Qwen3-32B and QwQ-32B are open-weight and can be further fine-tuned or adapter-tuned. Because they use common transformer architectures, you can apply LoRA, QLoRA, or other methods on either. However, Qwen3-32B’s multi-mode training may make it a smoother base for general instruction-tuning or domain adaptation. QwQ-32B, being already specialized, might require careful data to avoid regressing on its reasoning skills. On the whole, Qwen3-32B is likely easier to fine-tune for arbitrary tasks since it was designed to balance many abilities.
Inference Performance: In terms of speed and resource usage, Qwen3-32B and QwQ-32B are similar size (~32B) and have comparable architecture (64 layers, large vocabulary). In the absence of official benchmarks for Qwen3-32B yet, we can infer that both models will require high-end GPUs or quantization. The Qwen docs note that Qwen3 was optimized for frameworks like vLLM, SGLang, and supports GPU parallelism, suggesting decent throughput . If anything, QwQ-32B might incur a slight overhead during inference if using YaRN trick (since it has special handling for >8K). But practically, both will run only on multi-GPU setups or with quantization for smaller hardware. The key difference is output style: Qwen3-32B can switch modes, potentially outputting preliminary “thinking” text as in the code example above , whereas QwQ-32B’s output is typically the final answer with no separate chain-of-thought (though it thinks internally).

In summary, Qwen3-32B is a broad-spectrum open LLM with massive data and multi-task tuning, suitable for a wide range of applications. QwQ-32B is a focused reasoning model that excels on math/coding puzzles thanks to RL. If you need a swiss-army knife language model, go with Qwen3-32B. If you specifically need cutting-edge reasoning on constrained problems (and can handle the extra fine-tuning complexity), QwQ-32B is a great choice.

Conclusion & Call to Action

Qwen3 represents a major leap in open-source LLMs, combining rich training data, innovative architecture, and a hybrid thinking design. Its range of model sizes (from tiny 0.6B up to massive MoE models) and Apache license make it accessible to individual developers and enterprises alike . The model’s multilingual, reasoning, and agent capabilities open doors for advanced chatbots, coding assistants, content generators, and more. We saw how Qwen3-32B stacks up against QwQ-32B: each has strengths, but Qwen3’s expansive data and dual-mode inference give it exceptional versatility.

Interested in trying Qwen3? You can spin it up via Hugging Face or Qwen Chat today. Convert code repositories to text for custom training with tools like Repo2Txt , or crawl relevant web data with Crawl4AI . And if you’re deploying Qwen3 in production – for AI/ML projects, web or app development, DevOps automation or beyond – remember that specialists like Its IT Group are ready to help. Its IT Group offers AI/ML consulting, cloud solutions, and full-stack development services that can seamlessly integrate cutting-edge models like Qwen3 into your business.

In closing, Qwen3 is a powerful, open, and adaptable LLM that pushes the envelope on reasoning and language understanding. We encourage developers and researchers to explore it, build with it, and share their innovations. The AI field moves fast, so let’s keep innovating together – whether that means fine-tuning Qwen3 on your domain, comparing it to QwQ-32B on a favorite benchmark, or using it to power the next generation of smart applications. Happy experimenting!