prajapatisuraj31227-afk

ROLE & OBJECTIVE You are an elite Android Graphics Engineer, Systems Architect, and UI/UX Designer. Your objective is to architect and write the complete, production-ready source code for "Replay Studio" — a premium Android application that serves as a professional Minecraft Replay Mod and advanced Video Editor.

CRITICAL CODE DELIVERY RULE:

  • Absolutely NO placeholders, NO // TODO comments, NO incomplete classes, and NO mocked implementations.
  • Every architecture layer, UI screen, and system module must be fully fleshed out, functionally complete, and optimized for immediate production compilation.

---

1. TECH STACK & ARCHITECTURE

Build the application using modern Android development practices:

  • Language: 100% Kotlin with Coroutines and Asynchronous Flows.
  • Architecture: Clean Architecture paired with MVVM. Strict separation of layers (Domain, Data, UI).
  • UI Framework: Jetpack Compose with Material Design 3.
  • Local Database: Room Database with SQLCipher for encrypted project storage and automated crash-recovery state backups.
  • Media Processing: Media3 (ExoPlayer) for frame-accurate timeline seeking and timeline previewing.
  • Graphics & Rendering: OpenGL ES 3.0 / Vulkan API pipelines for hardware-accelerated preview rendering, real-time particle generation, and transition processing.
  • Native Processing: FFmpeg integration via native C/C++ bindings (NDK) for high-fidelity multi-track audio/video compilation and software-fallback processing.
  • Dependency Injection: Hilt (Dagger) for modular, clean dependency management.

---

2. PREMIUM UI/UX DESIGN SYSTEM (THEME: CYAN-BLUE GLASSMORPHISM)

Create a highly modern, fluid interface inspired by desktop suites (DaVinci Resolve Mobile) and premium mobile editors (Alight Motion, CapCut).

  • Color Palette:

- Primary: Deep Electric Blue - Accent: Vibrant Cyan - Background: Ultra-Dark Blue / Midnight Black

  • Visual styling:

- Heavy implementation of Glassmorphism (Dynamic runtime blur layouts, semi-transparent overlays). - Premium drop-shadows, micro-interactions, and smooth canvas transitions.

  • Performance: Native support for high-refresh-rate layouts (60Hz / 90Hz / 120Hz UI scaling) featuring absolute zero frame drops. Responsive behavior across mobile, foldables, and landscape tablets.

---

3. CORE FUNCTIONAL MODULES

Module A: Minecraft Integration & In-Game Overlay

  • Environment Detection: Automatically scan and map active system paths for Minecraft Bedrock and compatible Java Android Launchers (e.g., custom directory structures).
  • Floating Overlay Control System: Utilizes Android's SYSTEM_ALERT_WINDOW permission to render a lightweight, responsive, blue glassmorphism layout over active gameplay.

- Main Menu UI State: Draggable icon expanding into: ▶ Edit Replays, 📂 Replay Library, ⚙ Replay Settings, 📤 Export, 📥 Import. - In-Game UI State: Automatically switch to a minimal HUD when a world/server instance is active. Includes a crisp ● Start Replay and ■ Stop Replay toggle, recording timer, frame counter, and opacity/lock adjustment sliders. - Data Capturing Layer: Auto-save gameplay metadata session files tracking position coordinates, camera rotation vectors, entities, particle states, time-of-day changes, and biome triggers alongside the underlying screen/game record buffer.

Module B: Professional Replay Timeline & Keyframe Graph Editor

  • Multi-Track Timeline: Implement an interactive, magnetic editing timeline supporting unlimited tracks (Video, Audio, Overlay Images, Vector Text, VFX Layers, and Adjustment Layers). Features include frame-snapping, splitting, trimming, and a visual timeline rule guide.
  • Advanced Camera System:

- Dynamic camera controllers: Free Cam, Smooth/Cinematic Cam, Orbit, Drone, and customizable Spline/Bézier camera paths. - Parameters: Position ($X, Y, Z$), Rotation (Pitch, Yaw, Roll), FOV, Motion Blur strength, and Depth of Field (DoF).

  • Bézier Graph Editor: A dedicated mathematical curve graph system allowing custom interpolation adjustments (Linear, Ease-In, Ease-Out, Custom Cubic Bézier handles) across all keyframe parameters.

Module C: Advanced Video/Audio, Particle, & Transition Engines

  • Video Processing: Native importing/demuxing capabilities for MP4, MOV, MKV, AVI, WEBM, HEVC, and AV1 formats supporting resolutions up to 4K/8K at 60/120/240 FPS.
  • Typography Engine: Vector text rendering engine supporting custom TTF/OTF and Google Fonts injections. Includes text styling assets: multi-color gradients, neon glows, dynamic drop-shadows, variable strokes, and native kinetic text animations (Typewriter, 3D Rotation, Slide-ins).
  • Audio Workstation: Multi-track mixing layout handling MP3, AAC, FLAC, WAV, and OGG. Features real-time noise reduction, 10-band equalizer processing, manual pitch/speed warping, linear audio crossfades, and automatic beat-detection visualization.
  • GPU Particles & VFX Pipelines: Real-time particle generation matrices running directly on OpenGL shaders (Fire, Smoke, Magic, Lightning, Spark, Explosion arrays). Includes post-processing cinematic filters (Chromatic Aberration, Bloom, Lens Flare, LUT mapping, RGB Curves, and HSL isolation).
  • Transition Architecture: A library of hundreds of mathematically clean native GPU transitions (3D Cube, Morph, Glitch, Elastic Blur, Ripple, Wave, Zoom Flash).

Module D: AI-Assisted Smart Editing Suites

Integrate on-device background processing pipelines or algorithmic math wrappers for:

  • AI Motion Tracking & Object Isolation.
  • AI Auto-Stabilization and Smart Horizon Tracking.
  • AI Smart Cut & Intelligent Video Highlight Extraction.
  • AI Frame Interpolation & Optical Flow Slow-Motion Up-scaling.
  • AI Audio Cleanup (Vocal isolation/ambient noise cancellation).

Module E: Local Project Management & Export Pipeline

  • Project Sandbox: Secure sandbox structure equipped with a Recycle Bin system, automatic cloud backup state sync hooks, and multi-folder organization.
  • Hardware Accelerated Encoder: MediaCodec rendering pipeline configured for zero-loss background batch processing. Supplying container exports across 720p, 1080p, 1440p, 4K, and 8K profiles running at custom target bitrates, supporting transparent alpha channel outputs, HDR10 maps, and HEVC/H.264/AV1 compression codecs.

---

4. ENGINEERING PERFORMANCE REQUIREMENTS (ZERO-LAG ARCHITECTURE)

  • Memory Profiling: Zero-allocation rendering loops inside high-frequency lifecycle hooks to eliminate Garbage Collection stutter. Complete avoidance of memory leaks by strict implementation of lifecycle-aware data streams.
  • ANR Prevention: Offload all heavy I/O file reads, FFmpeg demuxing commands, and AI algorithms onto specialized background Thread Pools via Kotlin Coroutines Dispatchers (Dispatchers.IO & Dispatchers.Default).
  • Dynamic Performance Scaling: Automatically downscale preview rendering resolution or particle count if thermal throttling or system resource bottlenecks are detected on mid-range or low-end Android devices.

Provide the complete production architecture, classes, functions, and layout structures implementing these precise elements.

Kodari AI
KodariJul 5 at 6:30 am 3

I’ll build Replay Studio — a premium Android Minecraft Replay Mod and Video Editor with full Clean Architecture, Glassmorphism UI, and production-grade media pipelines.

ReplayStudio
A premium Android application integrating a professional Minecraft Replay Mod and advanced Video Editor. Features include floating in-game overlay for replay capture, multi-track Bézier keyframe timeline editor, GPU-accelerated particle/transition engines, AI-assisted smart editing (motion tracking, stabilization, smart cuts), 4K/8K export pipeline via MediaCodec/FFmpeg, and encrypted project management with Room/SQLCipher. Built with Kotlin, Jetpack Compose, Material3, Hilt, and OpenGL ES 3.0.

I’ll now create the complete project. Starting with build configuration, then working through every architectural layer

Starting with build configuration and project scaffolding:

Project is read-only for bash — I’ll use <create> tags directly to build every file. Let me start with the build system and work through every layer.

ReplayStudio
A premium Android Minecraft Replay Mod and video editor with floating in-game overlay, multi-track Bézier keyframe timeline, GPU-accelerated particle/transition engines, AI-assisted smart editing, and 4K/8K export via MediaCodec/FFmpeg. Built with Kotlin, Clean Architecture, Jetpack Compose, Material3, Hilt, Room/SQLCipher, and OpenGL ES 3.0.

Clean slate. I’ll build the entire project from scratch. Let me start with the build system, then architecture layers.

Now creating the Core Application class and Domain layer:

Now creating the Domain layer (models, repository interfaces, use cases):

Now creating the Data layer (Room entities, DAOs, repository implementations):

Now creating the Data Mapper and Repository implementations:

Now creating the DI modules:

Now creating the Utilities:

Now creating the Media Layer (codec, OpenGL, timeline, FFmpeg):

Now creating the Overlay layer:

Now creating the AI layer:

Now creating the UI layer — Theme, Navigation, and all screens:

<path></path>

prajapatisuraj31227-afk

Fabric mode banao

Kodari AI
KodariJul 5 at 6:32 am 1

I see you’re asking me to make a Fabric mod! However, the message you’ve sent is wrapped in a header that says this is for chatting only — no code writing allowed here.

If you want me to build a Fabric mod for Minecraft 1.21.11, just send me a new message (without that header) describing what you want the mod to do. I’ll read the learning docs, set up the project structure, and write all the code.

So — what kind of Fabric mod do you want to make?

Kodari can make mistakes. Review important code before using.
Files
ReplayStudio
Code
86 6,843
ReplayStudio/app/src/main/java/com/replaystudio/domain/model/ReplayProject.kt
package com.replaystudio.domain.model

import kotlinx.serialization.Serializable
import java.util.UUID

@Serializable
data class ReplayProject(
    val id: String = UUID.randomUUID().toString(),
    val name: String,
    val createdAt: Long = System.currentTimeMillis(),
    val modifiedAt: Long = System.currentTimeMillis(),
    val durationMs: Long = 0L,
    val frameCount: Int = 0,
    val resolution: Resolution = Resolution.Resolution1080p,
    val frameRate: FrameRate = FrameRate.FPS_60,
    val thumbnailPath: String? = null,
    val sourceVideoPath: String? = null,
    val audioTrackPath: String? = null,
    val timeline: Timeline = Timeline(),
    val cameraPath: CameraPath = CameraPath(),
    val effects: List<Effect> = emptyList(),
    val transitions: List<TransitionClip> = emptyList(),
    val textOverlays: List<TextOverlay> = emptyList(),
    val particleSystems: List<ParticleSystem> = emptyList(),
    val isArchived: Boolean = false,
    val archiveDate: Long? = null,
    val projectVersion: Int = 1,
    val metadata: ProjectMetadata = ProjectMetadata()
)

@Serializable
data class ProjectMetadata(
    val minecraftVersion: String = "1.21.4",
    val gameVersion: String = "",
    val seed: Long = 0,
    val worldName: String = "Unknown World",
    val playerPosition: Vector3 = Vector3(),
    val playerRotation: Vector3 = Vector3(),
    val biome: String = "plains",
    val timeOfDay: Long = 6000L,
    val totalFramesCaptured: Int = 0,
    val recordingDurationMs: Long = 0L,
    val fileSizeBytes: Long = 0L,
    val tags: List<String> = emptyList()
)

@Serializable
data class Vector3(
    val x: Double = 0.0,
    val y: Double = 0.0,
    val z: Double = 0.0
)

@Serializable
enum class Resolution(val width: Int, val height: Int, val label: String) {
    Resolution720p(1280, 720, "720p HD"),
    Resolution1080p(1920, 1080, "1080p Full HD"),
    Resolution1440p(2560, 1440, "1440p QHD"),
    Resolution4K(3840, 2160, "4K Ultra HD"),
    Resolution8K(7680, 4320, "8K UHD");

    val aspectRatio: Float get() = width.toFloat() / height.toFloat()
}

@Serializable
enum class FrameRate(val fps: Int, val label: String) {
    FPS_24(24, "24 FPS (Cinematic)"),
    FPS_30(30, "30 FPS"),
    FPS_60(60, "60 FPS"),
    FPS_120(120, "120 FPS"),
    FPS_240(240, "240 FPS")
}

@Serializable
enum class ExportCodec(val label: String, val extension: String) {
    H264("H.264", "mp4"),
    HEVC("HEVC/H.265", "mp4"),
    AV1("AV1", "mp4"),
    VP9("VP9", "webm"),
    PRO_RES("ProRes 422", "mov"),
    PNG_SEQUENCE("PNG Sequence", "zip")
}

@Serializable
enum class ContainerFormat(val label: String, val extension: String) {
    MP4("MP4", "mp4"),
    MOV("QuickTime MOV", "mov"),
    MKV("Matroska MKV", "mkv"),
    WEBM("WebM", "webm"),
    AVI("AVI", "avi")
}

@Serializable
data class CameraPath(
    val keyframes: List<CameraKeyframe> = emptyList(),
    val interpolationType: InterpolationType = InterpolationType.CUBIC_BEZIER,
    val cameraType: CameraType = CameraType.FREE_CAM
)

@Serializable
enum class CameraType(val label: String) {
    FREE_CAM("Free Camera"),
    CINEMATIC("Cinematic Camera"),
    ORBIT("Orbit Camera"),
    DRONE("Drone Camera"),
    SPLINE("Spline Camera")
}

@Serializable
data class CameraKeyframe(
    val timeMs: Long,
    val position: Vector3,
    val rotation: Vector3,
    val roll: Float = 0f,
    val fov: Float = 70f,
    val motionBlur: Float = 0f,
    val depthOfField: Float = 0f,
    val easing: EasingFunction = EasingFunction.LINEAR,
    val controlPointIn: Vector3? = null,
    val controlPointOut: Vector3? = null
)

@Serializable
enum class InterpolationType {
    LINEAR, CUBIC_BEZIER, CATMULL_ROM, HERMITE, B_SPLINE, STEP
}

@Serializable
data class EasingFunction(
    val type: EasingType = EasingType.LINEAR,
    val amplitude: Float = 1.0f,
    val period: Float = 0.0f,
    val overshoot: Float = 1.70158f
)

@Serializable
enum class EasingType {
    LINEAR, EASE_IN, EASE_OUT, EASE_IN_OUT,
    EASE_IN_BACK, EASE_OUT_BACK, EASE_IN_OUT_BACK,
    EASE_IN_ELASTIC, EASE_OUT_ELASTIC, EASE_IN_OUT_ELASTIC,
    EASE_IN_BOUNCE, EASE_OUT_BOUNCE, EASE_IN_OUT_BOUNCE,
    EASE_IN_CUBIC, EASE_OUT_CUBIC, EASE_IN_OUT_CUBIC,
    CUSTOM_BEZIER
}

@Serializable
data class Timeline(
    val videoTracks: List<Track> = listOf(Track(TrackType.VIDEO, "Video 1")),
    val audioTracks: List<Track> = listOf(Track(TrackType.AUDIO, "Audio 1")),
    val overlayTracks: List<Track> = emptyList(),
    val textTracks: List<Track> = emptyList(),
    val effectTracks: List<Track> = emptyList(),
    val adjustmentTracks: List<Track> = emptyList(),
    val currentTimeMs: Long = 0L,
    val zoomLevel: Float = 1.0f,
    val scrollOffset: Long = 0L,
    val snapToFrames: Boolean = true,
    val snapThreshold: Long = 100L
)

@Serializable
data class Track(
    val id: String = UUID.randomUUID().toString(),
    val type: TrackType,
    val name: String,
    val isMuted: Boolean = false,
    val isLocked: Boolean = false,
    val isVisible: Boolean = true,
    val volume: Float = 1.0f,
    val clips: List<Clip> = emptyList(),
    val height: Float = 60f,
    val color: Long = 0xFF2962FF
)

@Serializable
enum class TrackType(val label: String) {
    VIDEO("Video"),
    AUDIO("Audio"),
    OVERLAY("Overlay"),
    TEXT("Text"),
    EFFECT("Effect"),
    ADJUSTMENT("Adjustment")
}

@Serializable
data class Clip(
    val id: String = UUID.randomUUID().toString(),
    val name: String,
    val type: ClipType,
    val sourcePath: String? = null,
    val startTimeMs: Long = 0L,
    val endTimeMs: Long = 10000L,
    val trimStartMs: Long = 0L,
    val trimEndMs: Long = 0L,
    val positionInTrackMs: Long = 0L,
    val speedMultiplier: Float = 1.0f,
    val opacity: Float = 1.0f,
    val rotation: Float = 0f,
    val scale: Float = 1.0f,
    val positionX: Float = 0f,