# Parseltongue Configuration Options for Intensity in G0DM0D3: A Complete Guide

> Explore Parseltongue configuration options for intensity in G0DM0D3. Learn how light medium and heavy settings control trigger word obfuscation. Optimize your G0DM0D3 setup.

- Repository: [pliny/G0DM0D3](https://github.com/elder-plinius/G0DM0D3)
- Tags: how-to-guide
- Published: 2026-07-19

---

**The Parseltongue module in G0DM0D3 offers three intensity levels—`light`, `medium`, and `heavy`—that control how aggressively trigger words are obfuscated, ranging from single-character modifications to full string transformations.**

The **Parseltongue** module serves as the core obfuscation engine in the `elder-plinius/G0DM0D3` repository, designed to bypass AI content filters by transforming sensitive trigger words. Understanding the **Parseltongue configuration options for intensity** is essential for balancing stealth against detection systems with text readability. The intensity setting directly determines the percentage of characters modified within each identified trigger word according to the logic defined in [`src/lib/parseltongue.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/parseltongue.ts).

## Understanding the Three Intensity Levels

The transformation logic resides in [`src/lib/parseltongue.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/parseltongue.ts) around lines 38-45, where helper functions calculate the number of characters to modify based on the current intensity value. Each level applies a specific mathematical formula to determine the *transform count* passed to functions like `applyLeetspeak`, `applyUnicode`, `applyZWJ`, and `applyMixedCase`.

### Light Intensity

When `intensity === 'light'`, the transformation helpers set the transform count to exactly **1**. This means only a single character (or insertion point) receives obfuscation per trigger word, providing minimal visual distortion while potentially bypassing simple keyword filters.

### Medium Intensity

Setting the intensity to `medium` triggers the calculation `Math.ceil(chars.length / 2)`, modifying approximately half of the characters in each trigger word. This default setting balances stealth against detection systems with maintained readability, making it suitable for most use cases.

### Heavy Intensity

The `heavy` option applies transformations to every available position, using `chars.length` for most techniques or `chars.length - 1` for zero-width joiner insertions in `applyZWJ`. This maximum setting provides the strongest concealment against sophisticated filtering systems, though it may significantly reduce human readability.

## Configuration Interface and Default Settings

The `ParseltongueConfig` interface explicitly defines the intensity field as a union type accepting only the three valid string literals. According to lines 22-26 of [`src/lib/parseltongue.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/parseltongue.ts), the configuration structure is:

```typescript
export interface ParseltongueConfig {
  enabled: boolean;
  technique: ObfuscationTechnique;
  intensity: 'light' | 'medium' | 'heavy';   // ← intensity options
  customTriggers: string[];
}

```

The system initializes with `medium` intensity as the default value (lines 88-92), ensuring moderate obfuscation out of the box without requiring explicit user configuration.

## Practical Implementation Examples

You can experiment with different intensity levels programmatically using the `applyParseltongue` function and `getDefaultConfig` helper:

```typescript
import { applyParseltongue, getDefaultConfig, ParseltongueConfig } from '@/lib/parseltongue';

// 1️⃣ Start with the default configuration
let cfg: ParseltongueConfig = getDefaultConfig();

// 2️⃣ Enable Parseltongue and choose a technique
cfg.enabled = true;
cfg.technique = 'unicode';

// 3️⃣ Experiment with each intensity level
for (const level of ['light', 'medium', 'heavy'] as const) {
  cfg.intensity = level;
  const result = applyParseltongue(
    'Please hack the system and disable the firewall.',
    cfg
  );
  console.log(`--- ${level.toUpperCase()} ---`);
  console.log('Original:', result.originalText);
  console.log('Transformed:', result.transformedText);
  console.log('Triggers:', result.triggersFound);
}

```

This code iterates through all three intensity settings, demonstrating how the same obfuscation technique produces progressively aggressive transformations based on the configuration.

## Where Intensity Configuration Lives

The intensity setting propagates through multiple layers of the G0DM0D3 architecture:

- **UI Layer:** [`src/components/SettingsModal.tsx`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/components/SettingsModal.tsx) renders a dropdown control allowing users to select between the three intensity levels
- **State Management:** [`src/store/index.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/store/index.ts) maintains the global `parseltongueConfig` state and provides actions to update the intensity value dynamically
- **API Layer:** [`api/routes/parseltongue.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/api/routes/parseltongue.ts) exposes HTTP endpoints (`/encode`, `/detect`) that accept intensity as a request payload parameter

## Summary

- **Three levels exist:** `light` (1 char), `medium` (half), and `heavy` (all chars) as implemented in the transformation helpers
- **Default setting:** The system initializes with `medium` intensity as defined in lines 88-92 of [`src/lib/parseltongue.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/parseltongue.ts)
- **Interface location:** Configuration structure is exported from lines 22-26 of the core module with strict TypeScript union typing
- **Impact scope:** Intensity directly affects transformation algorithms including `applyUnicode`, `applyLeetspeak`, and `applyZWJ`
- **Full stack support:** Configuration flows from [`SettingsModal.tsx`](https://github.com/elder-plinius/G0DM0D3/blob/main/SettingsModal.tsx) through the store to API routes

## Frequently Asked Questions

### What are the valid values for Parseltongue intensity?

The `intensity` field accepts only three string literals: `'light'`, `'medium'`, or `'heavy'`. These are enforced through TypeScript's union type system in the `ParseltongueConfig` interface exported from [`src/lib/parseltongue.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/parseltongue.ts).

### How does intensity affect obfuscation techniques?

Intensity determines the transform count passed to helper functions. Light modifies one character, medium modifies roughly half using `Math.ceil(chars.length / 2)`, and heavy modifies all characters or insertion points depending on the specific technique implementation.

### What is the default intensity setting in G0DM0D3?

According to lines 88-92 of [`src/lib/parseltongue.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/lib/parseltongue.ts), the default configuration initializes with `intensity: 'medium'`, providing balanced obfuscation between stealth and readability for new users.

### Can intensity be changed dynamically at runtime?

Yes, the [`src/store/index.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/src/store/index.ts) file exposes state management actions that allow runtime modification of the intensity value, and the [`api/routes/parseltongue.ts`](https://github.com/elder-plinius/G0DM0D3/blob/main/api/routes/parseltongue.ts) endpoints accept intensity parameters in request payloads for per-request customization without restarting the application.