Parseltongue Configuration Options for Intensity in G0DM0D3: A Complete Guide

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.

Understanding the Three Intensity Levels

The transformation logic resides in 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, the configuration structure is:

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:

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 renders a dropdown control allowing users to select between the three intensity levels
• State Management: src/store/index.ts maintains the global parseltongueConfig state and provides actions to update the intensity value dynamically
• API Layer: 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
• 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 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.

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, 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 file exposes state management actions that allow runtime modification of the intensity value, and the api/routes/parseltongue.ts endpoints accept intensity parameters in request payloads for per-request customization without restarting the application.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}