Budget: 6500 UAH Deadline: 8 days

Hello! I was compiling C libraries to WebAssembly using Emscripten and offloading heavy computations to Web Workers to prevent the UI from freezing — this task is exactly like that. Cubiomes compiles to WASM fine, I keep the generation of biomes and structures in a worker, and on the canvas, you do zoom/pan with tile loading based on coordinates. A question about versions: do we need to support a range of Minecraft Java (approximately 1.16–1.21) or just one specific version? This affects how many branches of Cubiomes generation to enable. Approximately a week for the working viewer.

Budget: 27000 UAH Deadline: 60 days

MVP evaluation - 20,000 USD and 60 calendar days, provided we start with Overworld, a basic set of structures, layers, URL state, and further expansion into Nether and End.

Experience with WebAssembly and Emscripten, browser optimization, interactive maps, and complex web tools. With Cubiomes, I wouldn't pretend that everything here is trivial - !!Cubiomes in the browser via WebAssembly and Web Workers need to be checked in a technical phase for accuracy and performance!!. We can take this as the first stage to avoid building a nice interface around inaccurate generation. The devil is in the details, here it literally concerns seed, version, and coordinates =)

> Approach - We compile Cubiomes into WebAssembly, move generation to Web Workers, build the map tile-based or chunk-based to avoid generating unnecessary areas.
> Rendering - OpenLayers with a custom layer for biomes and separate vector layers for structures, markers, coordinates, and filters.
> Risks - Different support for structures in Java Edition versions, accuracy of spawn point, Nether and End within Cubiomes, browser memory at high zoom levels.

Clarification - which 5-7 versions of Minecraft Java are a priority for you in the MVP, and will the design be ready from your designer, or do we need to create the UI ourselves?

Similar complexity cases:
> https://business.ingello.com/city-ingello - mapping service with points and display logic.
> https://business.ingello.com/svitbus - complex map, routes, search, roles, and stable web logic.
> https://business.ingello.com/fractal - example of complex engineering automation, closer to the technical complexity of the task.

Main page of Ingello for Freelancehunt - https://systems-fl.ingello.com/ua Expand

Budget: 24000 UAH Deadline: 10 days

Hello.

I have reviewed the specifications for the Minecraft Java Seed Map / Seed Viewer. The task is clear: we need to implement a browser-based tool with client-side generation using Cubiomes, WebAssembly, Web Workers, an interactive map, biomes, structures, layer toggles, coordinates, and a shareable URL.

I suggest developing the MVP in stages:

1. Integration of the Cubiomes C library via Emscripten/WebAssembly.
2. Offloading generation to a Web Worker to avoid blocking the UI.
3. Implementation of seed input: numeric seed, text seed using Java hashCode logic, random seed.
4. Version selector for supported Java Edition versions.
5. Tile-based map generation to avoid generating excessive data at once.
6. Interactive map using OpenLayers or a Canvas-based tile renderer.
7. Display of biomes, structures, coordinates, and layer toggles.
8. Shareable URL for restoring seed/version/dimension/position/zoom.
9. Preparation of a component for integration on the `/minecraft-seed-map` page.

I see the main risks in the accuracy of supporting different Minecraft Java versions, structures for new versions, browser generation performance, and the correct functioning of WASM in the Web Worker. That’s why I propose to first create a technical prototype: Cubiomes → WASM → Worker → generation of biomes/structures for a single seed/version, and then scale it to a full MVP.

For the MVP, approximately 1-2 weeks will be needed depending on the final list of versions, structures, and design.
I can implement the tool in a structured way, considering future support and integration into the site.
Portfolio: Freelancehunt

I have a sample that I can send you in messages. Expand

Budget: 13000 UAH Deadline: 2 days

Good day.
upd: I already have a full working version.

I am interested in your project. I personally love Minecraft, so the task with the seed map is really interesting to me, not just "another web tool."

I will be honest right away: creating a full analog of Cubiomes Viewer with all versions, dimensions, and structures for this budget is unrealistic. However, we can properly assemble the first working MVP, which will then be easy to expand.

I am currently trying this platform and want to get some good initial feedback, so I am ready to take on the first stage for 13,000 UAH.

In the first version, I can implement seed input, random seed, text seed with conversion like in Java, selection of Minecraft version, an interactive map with zoom and pan, X/Z coordinates, copying coordinates, shareable URL, basic layers, displaying Overworld biomes, and a few main structures.

On the technical side, I see it this way: connect Cubiomes via WebAssembly, offload heavy generation to a Web Worker, and create the map not all at once, but in parts based on the visible area. This way, the page won't freeze while moving around the map.

I wouldn't include Nether, End, and a large list of all structures in the first stage. It's better to first create a stable foundation, check the accuracy of the seeds, and then add more versions and structures.

Before starting, I would like to clarify a few things:

1. Which Minecraft Java versions are most important to you?
2. Can the first MVP be made only for Overworld?
3. Which structures are definitely needed in the first version?
4. Do you have seeds for checking the accuracy of the coordinates?

Estimated timeframe: 14-18 days
upd: 1 day.

If this format works for you, I can start with the MVP and bring it to a state that can already be shown to users on the site. Expand

Budget: 5000 UAH Deadline: 10 days

Good day! I will complete your project quickly and efficiently! I have been working with Minecraft for 8 years!

Budget: 7000 UAH Deadline: 10 days

Hello, the task is complex but very interesting: precise seed generation, performance, and careful UX are critically important here. I have worked with TypeScript, interactive UIs, and front-end optimization, so I can build an MVP without lags: Web Worker for generation, client integration with Cubiomes/WASM, Minecraft versions, biomes, structures, zoom/pan, and shareable URL. For the map, I will suggest tile-based rendering through canvas or OpenLayers — depending on which provides better speed. I am ready to discuss the risks regarding versions and the timeline for the MVP.

Budget: 27000 UAH Deadline: 21 days

Hello!

I have reviewed your task, I have experience working on similar projects and I understand the objectives set.

I suggest we discuss the details in private messages.

Budget: 27000 UAH Deadline: 10 days

Hello! I am interested in your project. I have experience with TypeScript, WebAssembly, Web Workers, OpenLayers, and developing complex browser-based tools.
For implementation, I propose Cubiomes + WebAssembly (Emscripten) + Web Workers for generating a UI without lags and OpenLayers for working with maps and layers.
I can implement an MVP with support for seed, Minecraft Java versions, biomes, structures, coordinates, shareable URL, layer toggles, and an interactive map.
The estimated timeline for the MVP is 4-6 weeks.
I am ready to discuss the details and suggest the project architecture.

Budget: 18000 UAH Deadline: 8 days

Good day!

I have carefully reviewed the specifications. I understand that the main complexity of the project lies not in displaying the map, but in the correct generation of the Minecraft Java World through Cubiomes, supporting various versions of the game and ensuring stable operation in the browser.

(I have indicated the budget and timelines)

What I propose:

• Integration of Cubiomes via WebAssembly (Emscripten)
• Offloading all generation to Web Workers to avoid UI freezes
• Tile-based map generation for efficient operation at large scales
• Support for numeric and text seeds with correct conversion according to Minecraft Java Edition
• Support for Minecraft Java versions that are compatible with Cubiomes
• Displaying biomes and structures as separate layers
• Shareable URL with restoration of seed, version, coordinates, and zoom
• Scaling, moving the map, X/Z coordinates, copying coordinates

For rendering the map, I suggest OpenLayers, as the library is well-suited for working with tiles, layers, markers, and large interactive maps.

My experience:
• 4 years of Frontend and Backend development
• 2 years of commercial experience in product and blockchain development
• TypeScript, React, Web Workers, optimization of browser application performance
• Working with large interactive interfaces and production solutions

Examples of work:

https://contentbuilder.ai/ — a commercial project (USA), where I worked as a Full Stack Developer and implemented a significant part of the functionality.

https://freelancehunt.com/showcase/work/procasino/2025898.html

https://freelancehunt.com/showcase/work/bionrgg/2025897.html

I also have experience developing a very similar project but for a PC application.

I would be happy to discuss the project details. Expand

Budget: 27000 UAH Deadline: 45 days

We already have an almost ready base for such a solution - an interactive browser tool with a map, layers, state in the link, and generation in workers, so we can quickly adapt it for a Minecraft seed viewer and launch the MVP.

For the MVP timeline, I would aim for 5-7 weeks, depending on the final list of Java Edition versions, structures, and how deeply we need to cover the Nether and End. The estimate is 180,000 UAH for the MVP with a proper architecture, not just a demo that looks good for the first 10 minutes and then goes to philosophize in the console =)

WebAssembly / Emscripten - yes, this approach is appropriate here. I would integrate Cubiomes through a separate wasm module, move the generation to a Web Worker, and make the map tile-based or chunk-based to avoid generating unnecessary areas and blocking the interface. For rendering, I would most likely use OpenLayers unless there is a requirement for a more custom canvas/WebGL visual. OpenLayers is well-suited for zoom/pan, coordinates, layers, markers, and state restoration via URL.

I see the risk with Minecraft versions in that different Java Edition versions affect biomes, structures, and the availability of individual objects differently. Therefore, I wouldn’t promise all versions at once, but would create a verified support list based on Cubiomes, with a matrix - version, dimensions, biomes, structures. This is one of those cases where it’s better to check the seed seven times than to beautifully draw the wrong map once.

From a technical standpoint, I see the implementation as follows:
- Compiling Cubiomes into WebAssembly via Emscripten
- A separate worker for generating biomes and structures
- Caching tiles/chunks in the browser
- Converting text seed to Java seed without losing compatibility
- Layers of biomes and structures with separate toggles
- X/Z coordinates, copying coordinates, hover or click
- Shareable URL for seed, version, dimension, position, and zoom
- An integration format so the tool can be embedded on the page /minecraft-seed-map

I’d like to clarify two points to avoid guessing about cubiomes, even though it sounds tempting:
- Which Minecraft Java versions are most important for the MVP - only current ones or is a broad historical list needed?
- Will the design already be from your designer, or do we need to prepare our own neat UI for desktop and responsive?

Examples of similar experience from Ingello:
- https://business.ingello.com/vorfahr - a complex web system with automation, data logic, and integrations
- https://business.ingello.com/fractal - an example of architecture for complex processes, agent logic, and scalable modules
- https://systems-fl.ingello.com/ua - a brief overview of our approach to system development, automation, and AI solutions

I’m available to discuss the MVP composition, Minecraft versions, and technical risks right here on the marketplace. Expand

Budget: 25000 UAH Deadline: 20 days

Good day! We have experience working with Minecraft world generation algorithms and integrating interactive maps into web interfaces. We implement this through optimized chunk rendering on the client side using WebGL for high performance. We are ready to discuss the details of the architecture and the scalability of the solution for your needs.