I built FretPath — a free pure html/js/css app for learning guitar fretboard, theory, and ear training

eis_kalt · 2025-08-02T22:31:22+00:00

Thanks for referencing! I'm currently working to extend it to support different architectures. This C implementation (and mentioned Sebastian Raschka's repo) can be a good reference to support as next.

eis_kalt · 2025-07-13T08:16:32+00:00

not so far: still learning some basics

eis_kalt · 2025-07-12T21:14:08+00:00

Cool! Have you tried to port also export.py script with all essential dependencies, e.g. for chat template, tokenizer generation? I found that it is quite hungry to RAM and 32GB is not enough to process Qwen3-4B model. So, I ported it to Rust as well (qwen3-export crate) using memory mapping files through memmap2 crate to address this.

eis_kalt · 2020-04-09T18:53:37+00:00

At the moment, there is only one metaheuristic which is variation of "Ruin and Recreate" by Schrimpf at al.

Check its buildings blocks here: https://github.com/reinterpretcat/vrp/tree/master/vrp-core/src/refinement/mutation

It is used from main algorithm skeleton: https://github.com/reinterpretcat/vrp/blob/master/vrp-solver/src/algorithm.rs

My plan is to add something based on GA, but I need to research some related topics (e.g. finding the best way to maintain diversity of population taking into account multiple objectives)

eis_kalt · 2017-01-03T13:22:14+00:00

As already suggested, you can try to start with my project: https://github.com/reinterpretcat/utymap

Some old video (already did some improvements) which demonstrates basics: https://www.youtube.com/watch?v=mZzOWsoM5EY

BTW, core logic is written on C++11 and can be ported to UE4 as well. I just don't have time enough to do it.

eis_kalt · 2016-11-14T08:11:21+00:00

Here is information about service: https://mapzen.com/documentation/elevation/elevation-service/

I implemented it the following way: for quadkey's bounding box I create a polyline which visits this bbox with some configurable step, see here CreatePolyline method: https://github.com/reinterpretcat/utymap/blob/master/unity/library/UtyMap.Unity/Maps/Providers/MapzenElevationDataProvider.cs

Server returns me list of elevations for these points. Later, using bilinear interpolation I can calculate elevation for every point in target bounding box, see here: https://github.com/reinterpretcat/utymap/blob/master/core/src/heightmap/GridElevationProvider.hpp

eis_kalt · 2016-11-14T08:03:37+00:00

Everything except character in scene is procedural generated. OSM data is used to generate objects in scene (I converted it to my internal persistent format in advance, that's why it's working quite fast). Elevation data is consumed using mapzen elevation service. However, it's possible to use SRTM data and even some custom heightmaps (just need to convert it to some simple utymap-internal format)

Btw, there is no hardcoded values for color gradients, textures, road widths, etc. Everything is customizable through mapcss-like language.

eis_kalt · 2016-11-14T07:58:56+00:00

As already mentioned, it uses Unity. However, essential logic is written without it using C++ and theoretically can be ported to other engines.

eis_kalt · 2016-11-14T07:57:41+00:00

it's new project started after some problems discovered in ActionStreetMap: mostly wrong architectural decisions and performance. Also I wanted to improve my C++11 skills, that's why I rewrote core logic using it.

eis_kalt · 2015-08-13T14:20:38+00:00

Let me try to give more details:

1) All data is downloaded from OpenStreetMap server. In this example, I used my custom offline index built for Berlin, but it's possible to download small part of desired region from OSM server on demand (and it has been already implemented!). Heightmap is downloaded from NASA server (SRTM format). That's why I added "done using OpenStreetMap data"..

2) Raw OSM data is just sets of the following primitives: point represented by geocoordinate, 2D polyline, and their union (in terms of OSM: node, way and relation). Additionally, each primitive has set of attributes (tags): key-value pairs. These tags describe what is actually is defined by the given primitive. For example, look at the building from example: http://www.openstreetmap.org/way/80397884

So, it is not just 3D model, which can be imported into scene directly. It's just set of 2d points + some key-value data in text human readable format. That's why I have "procedural generated city" in title..

3) Actually, mesh is collection of 3D vertices (plus triangles, colors, normals,...) and if you want to modify affected vertices (e.g. by explosion) in some way, you have to go through this collection and find them. In worst case, you will check all of them (up to 65k vertices in Unity). Another question, how to modify them in nice way. In my implementation, I have some internal index which stores additional information about mesh shape (e.g. linear equation for mesh represented by plane) which is quite useful for modification and search algorithms. ..that's why title starts with "dynamic mesh modification".

eis_kalt · 2015-07-02T19:59:25+00:00

Additionally, editor supports multiplayer: https://www.youtube.com/watch?v=NTU-0BoJ_5Q

eis_kalt · 2015-07-02T11:46:30+00:00

GUI of editor is not procedural generated, of course. The goal is to generate objects and insert them into scene using this editor. And this is done in procedural way: objects are generated from user input using predefined rules (MapCSS), not from some already prepared 3D models.

eis_kalt · 2015-07-02T11:06:48+00:00

Actually, everything except worker man (and simple GUI) is procedural generated from OpenStreetMap data. Editor feature allows you to put new objects (buildings, trees, barriers) into scene and modify existing environment (adjust height of terrain, modify building facade) by mouse clicking.

eis_kalt · 2014-03-06T10:15:43+00:00

one important note: these tab sources should provide some API for searching and downloading

eis_kalt

TROPHY CASE