The SD 3D Model Generator is an innovative creative tool that bridges the gap between simple text inputs and fully developed 3D assets for game development, visualization, and creative prototyping. Unlike traditional Stable Diffusion (SD) frontends, this application accelerates the entire workflow by integrating advanced Large Language Models (LLMs):
Prompts are automatically optimized, seamless (topic-relevant) environment maps are generated, images of objects or characters are created and transformed into high-quality 3D models – all in an intuitive interface where you can view images as well as 3D models with environment maps.

What sets the tool apart?

• Prompt-to-Asset, End-to-End: Simply enter an object name or concept – the system guides you through the process, optimizing your prompt for Stable Diffusion via LLM, ensuring stylistic consistency, creative details, and optimal formatting.
• Simplified 3D Workflow: Generated images can be converted to 3D models (GLB) with one click. Additionally, a custom panorama environment (HDRI) can be created for each asset, ready to use in Blender or game engines.
• No prompt experience needed: The LLMs in the backend automatically transform rough ideas into professional, detailed prompts – saving time and reducing creative effort.
• Integrated Gallery & Batch Generation: Extensive collections of images and models can be efficiently managed through batch control, page navigation, and comparison view.

Features & User Experience

• Easy input, professional result: A simple object title (“low poly farmer”) is sufficient – the system uses LLMs to automatically optimize the Stable Diffusion prompts and always delivers the best possible image quality, composition, and clarity.
• Real-time streaming: LLM and image generation results are streamed live to the interface – for transparency and quick feedback.
• Intuitive galleries: Separate, tab-based galleries for 2D images and 3D models – assets can be compared, managed in batch, or edited directly. Context menus allow instant export, reuse of generation results, or direct model/HDRI creation.
• Automatic 3D model creation: Each generated image can be directly converted into a 3D GLB model via the UI (through external tools/scripts, flexibly configurable).
• Automatic environment map creation: A custom equirectangular HDRI environment can be generated for each model: LLMs first describe a suitable environment, then SD creates a photorealistic panorama for lighting and reflections.
• Batch control & placeholders: Support for batch image creation, placeholder management, and clear regeneration – keeping the current progress always traceable.
• One-click export to Blender: Models and HDRIs can be opened and further edited directly from the application in Blender.

Technical Overview

• Frontend:
  • Pure HTML/CSS/JavaScript, seamlessly integrated via PyWebview for direct access to the Python backend.
  • Dynamic, responsive UI logic for gallery, tabs, and context menus.
  • Live streaming of LLM outputs and image generation status via Python–JS bridge.
• Backend:
  • Python backend based on PyWebview and a FastAPI-like interface.
  • Integration of Ollama or local LLM servers (e.g., Mistral) for automatic prompt optimization and summarization.
  • Image generation via Stable Diffusion (diffusers library), all parameters (model, VAE, sampler, etc.) are user-configurable or set automatically.
  • External tools/scripts for converting images to 3D (GLB) and creating HDRI panoramas are modular and easily interchangeable.
  • Automatic file management, metadata embedding (JSON in PNG and sidecars), and monitoring of asset folders for live updates in the gallery.
• Extensibility:
  • Each backend process is decoupled and scriptable: The 3D conversion or HDRI creation can easily be replaced with custom pipelines.
  • Easily adaptable for different LLMs, SD models, or 3D workflows.

The SD 3D Model Generator radically simplifies the path from idea to finished asset. By combining LLMs, Stable Diffusion, and automated 3D workflows, artists, designers, and developers can generate, manage, and process high-quality visuals faster, more flexibly, and more creatively.

Auto-Git is a cross-platform Electron app that automatically monitors and manages Git repos and writes commit messages and documentation / READMEs using LLMs.

• Monitoring & Automatic Commit
  • – Add any folders as Git repositories: Auto-Git takes care of the initial Git setup if needed.
  • – Real-time file watching (Chokidar): As soon as files change, changes are detected in a debounce interval and automatically committed to Git.
  • – Intelligent commit messages: Once a defined line or time threshold is reached, Auto-Git collects all new commits, creates a prompt-optimized input for an Ollama-LLM (qwen2.5-Coder) from their diffs, and replaces the standard commit messages with semantically concise summaries.
• README Generation & Repository Description
  • – At the push of a button or upon initial addition: Auto-Git extracts relevant code files (by size, relevance score, .gitignore rules) and feeds them into an LLM prompt to automatically create or update a complete, well-structured README.md.
  • – LLM-assisted short description (≤ 255 characters): For each folder, Auto-Git can generate a one-liner project description text in fractions of a second using the same Ollama backend.
• Robust Folder Management
  • – Missing or moved folders are automatically detected (“Needs Relocation”), and by clicking on the sidebar icon, you can assign the new path and restore the original Git state (checked via commit hash).
  • – Simple drag-and-drop support: Drag folders directly into the app, instantly initialize a Git repo, and set it to monitoring.
  • – .gitignore management: Typical temporary/IDE/build files are automatically detected (Micromatch + predefined patterns) and added to .gitignore if needed.
• Gitea Integration & Push Workflow
  • – In the settings, a personal Gitea API token can be stored.
  • – When clicking “Push to Gitea”, Auto-Git checks if the remote repo already exists:
    1. Not available → Create repository (with LLM-generated short description).
    2. Available → Update current description via PATCH.
  • – Afterwards, the local remote origin is reconfigured, and the current branch including tags is automatically pushed.
• Desktop UI & Usability
  • – Electron & TailwindCSS: Responsive interface with sidebar (filtered list of all monitored folders), central content area (displays all commits paginated, including diff view, snapshot export, and “Jump Here” checkout).
  • – Sky Mode: Automatic time-dependent background (soft blue during the day, dark blue at night).
  • – Tray Menu & Tray Icon: App minimized to tray, right-clicking on the tray icon allows quick starting/stopping of monitoring per folder, adding/removing folders, “Quit”.
  • – Settings Dialog:
    • > Sky theme on/off
    • > “Close to Tray”: Hides window when closing, instead of actually quitting the app
    • > Automatic startup behavior
    • > Intelligent commit thresholds (lines and minutes)
    • > Selection of used Ollama models (commit vs. README)
    • > Store Gitea API token
  • – Gamification & Live Statistics: Daily counter for commits, color-increasing visualization (“Commits today”), live countdown until the next automatic LLM commit.
• Technology Stack
  • – Frontend: Electron + HTML/CSS + TailwindCSS + a custom minimal-animated “Anime Cat” (client-side cat streaming for LLM responses).
  • – Backend/Node:
    • > chokidar for file watching
    • > simple-git for all Git operations (Init, Status, Commit, Diff, Rebase, Push, Remote Config)
    • > micromatch & ignore for filtering files/folders
    • > electron-store for persistence of all settings (including Gitea token, sky mode, thresholds, model selection)
    • > Custom LLM integration: Start/Stop Ollama server, parallel stream handling via fetch(…).getReader().
    • > Tray/Menu integration with native Electron menus and context menus in sidebar/treeview.

All features – from continuous, automatic commit creation to fully automated push-and-repo setup on Gitea – are designed to make developers’ everyday lives easier: You can continue to focus on code while Auto-Git ensures that commit history, documentation, and remote repositories are always up to date.

The “Virtual Interdimensional Ghost Teleportation Device” is an interactive 3D web application that brings figures from Japanese mythology to life in the browser. Through a digital “Merkaba,” the beings are teleported into a virtual world, can be viewed, and explored via a click in an info box overlay.
A portfolio project aimed at learning about Japanese myths in German and building cultural bridges.

Frontend: Three.js
Backend: Node.js, Express, Websocket
3D Models: Hunyuan3D-2, edited in Blender
Info Texts: ChatGPT

The entire 3D environment including models and textures, such as a 1200px x 900px canopy texture and an HDRI environment map, as well as all the code, is smaller than 500 kilobytes. The 3D models are loaded dynamically; the client has no information about them until the server “pushes” them. The communication with the server as well as the spawn function are integrated into the spinner (Merkaba).
Mobile representation is less computationally intensive than the desktop version. An adaptive fidelity system has also been implemented.

In order for the pages of a book to have the correct order, a bit of mathematics is required. To print the “signatures” (sheets) of a book correctly, software that you have to pay for is usually necessary – alternatively, I provide a script that does exactly that.

It processes a PDF and generates a new PDF from it, which can then be printed directly using double-sided duplex printing (four pages per sheet – two on the front, two on the back).
You can simply specify how many sheets you want to bind per signature, and the script prepares everything accordingly.

It also has a “Manga” mode to prepare books that are read “back to front” (according to Western standards) for printing, and includes parameters to trim page margins.

The character 一日 can be read as “いちにち” (“the whole day”), or as ついたち (“the first day of the month”).
Depending on the context, the readings of some Kanji differ.

Furigana are a Japanese reading aid. They are Hiragana characters that are written next to or above a Kanji in Japanese writing to indicate its pronunciation.

Conventional Furigana software does not recognize the holistic meaning or context of a text, and is therefore sometimes unable to provide the Furigana in the way a Japanese reader would actually read the text.

However, with AI, this is now possible, which is why I programmed this software.
“Smart-Furi” analyzes the text for context, tone, etc., to add the appropriate readings as Furigana to the text – so that one does not learn the readings of the characters incorrectly, but as if a Japanese person were reading the text aloud.

The UNESCO project “Intangible Cultural Heritage” (ICH) offers an impressive collection of intangible cultural heritage as well as a register of best protection measures.
These can be found on the UNESCO website in English, French, and Spanish, beautifully describing the individual cultural peculiarities of the nations of the world.

As a friend of online ethnology, I have set up a new interface in the form of an interactive world map (JavaScript, OpenStreetMap & GeoJSON).
By clicking on a country, you gain insight into the culture of that country as registered by UNESCO (UNESCO Open Access Database).
Using the ChatGPT API and Python, I translated the entire database into the 10 most spoken languages in the world. Additionally, I improved/enlarged all images from the database with Topaz AI.

By clicking on the cube, a random entry is displayed.
Discover the world!

Note: Not suitable for mobile view

Sources:

• UNESCO Open Access Database: Metadata, descriptions, and images from the UNESCO ICH database were used for this project.
• OpenStreetMap: The map representation is based on tiles from OpenStreetMap.
• GeoJSON World Map: The vector data for the country outlines comes from the open-source GeoJSON project.
• IPAPI (ipapi.co): Automatic location determination is done via the API service ipapi.co.
• Topaz AI: The images from the UNESCO database were upscaled using Topaz AI.
• ChatGPT (OpenAI): The translations of the UNESCO data into 10 languages were created using ChatGPT.

This project is an experimental, non-commercial portfolio project and is for demonstration purposes only. All content (images, texts, titles) is the property of UNESCO. The translations were created using AI (ChatGPT). The map tiles come from OpenStreetMap. There is no connection to UNESCO, OpenStreetMap, or other organizations. The complete UNESCO metadata is available for download in English.

WordPress plugin to automatically translate pages, posts, and custom type posts as well as their titles and custom fields.
The translations are stored in the metadata of the posts.
Depending on the selected language, the frontend displays the language under the same URL / post ID.
In the Gutenberg editor, there is a small dropdown menu that allows you to switch between languages to make individual changes, and in the backend, unlike with Polylang, there is no confusing duplication of content.
The translation is done via ChatGPT, which allows for context-specific translation – by specifying what the tone should be, e.g., polite or informal, and what the focus should be, such as project presentation, marketing, etc., better translations can be obtained.

The code for selecting and processing content is available in a git repository.

The 2136 Kanji that are learned in elementary and middle school in Japan, which enable one to read most Japanese texts, along with their translations in German.

The meaning of a word often varies depending on the context. Many terms only arise when multiple Kanji are combined – that’s why the term “you” is not found here, for example.
It is composed of 貴 (valuable, noble, precious) and 方 (person).

The question of how to comprehensively categorize a language has proven to be very interesting.
The categorization by “school year” is a time-honored Japanese method – but the desire for finer granularity was present to make learning easier.

The Kanji list as a JSON file, the Python codes to create them, as well as the chosen categories can be found below in the git repository.