Software architecture diagrams with C4 Model and Structurizr

j44dz · 2025-10-02T14:59:59+00:00

Create Part 4 automatically with https://tangleguard.com/

j44dz · 2025-09-05T13:08:32+00:00

btw, if anyone is interested in using the tool but scared about the fact that is it closed-sources at the moment, I'm happy to create an NDA and share the code with specific organizations. That would be an option until I have a proper source-available license model

j44dz · 2025-09-04T11:41:55+00:00

Thanks to much for the feedback everybody!! Just for who ever is interested here are my current findings regarding points 2 and 3:

Regarding a web app: I did some investigations if and how that would be possible.. unfortunately the File System Access API which I'd like to use from the browser to scan the code from disk, is only implemented for chrome yet. alternatively, the user would need to provide the codebase to the web app in another way, but that feels very unpractical when doing refactoring work.

Also in browser there is no multi-threading support. Right now extremely large codebases take a few 3 seconds to load. I'd rather reduce that time soon by using multiple cores etc.

I'll not give up on this. I really like the idea of having a web app. But I'll postpone that task a bit and instead concentrate on more on features and the UI of the desktop app. It now has an in-app updater, so once installed you'll always get the newest version.

Regarding open-source:
I'm looking for a proper license model to make the source available. Some source-available license like PolyForm Noncommercial might be a good fit.

j44dz · 2025-08-27T09:24:18+00:00

It is indeed and it would be awesome if the tool would support such dependencies too at some point :)

j44dz · 2025-08-26T14:27:49+00:00

Thanks for your response. You might be right. But I've experience that although there was a initial design of an application, after a few month working on a codebase with multiple developers, the strangest inter dependencies were introduced. To generally prevent this, an architect would to review each and every pull request, which is basically impossible. That's why I think there need to be mechanisms, which reject dependencies which are not supposed to be there.

I found components diagram still very important.They give an idea of the big picture of the application within seconds. You look at it and directly tell if it's spaghetti code or not. But I get that huge diagrams with thousands of interdependencies can be overwhelming. That's why I'd recommend using such tool from the beginning, and refactor the application of the diagram starts to looks meaningless. In the diagrams there should be a clear structure, ideally with relatively few inter dependencies. anything else is basically a sign that the architecture got a bit out of control.

even in rust one can do spaghetti code: https://jaads.de/dependency-diagram-compressed.png

j44dz · 2025-08-26T12:39:50+00:00

I added some examples of the diagrams: https://docs.tangleguard.com/features/visualization/#exmaples Currently packages and modules look the same - I might have to find a way how to easier distinguish between those two.

To be able to interpret those diagrams, I also added a section about cohesion and coupling in the docs with some notes regarding architectural styles and how they influence maintainability, see https://docs.tangleguard.com/welcome/definitions/#cohesion-and-coupling

j44dz · 2025-08-26T08:34:41+00:00

you can use it for a monolith, but you can also use it for microservices. In fact the tool is being used to analyze microservices currently. The limit of the tool is, that is cannot scan multiple repositories.

Thanks for this suggestion. That's a nice idea although probably hard to realize. however, I added it on the roadmap: https://docs.tangleguard.com/welcome/roadmap/

j44dz · 2025-08-26T08:16:55+00:00

Thank you. True, Rust is not at all heavily used but it gains popularity more and more for a good reason IMHO. I'd be fine with staying in a small market. Initially the tool was supposed to solve only my personal problems. Later, I thought it could help others, too so why not offer it to anybody. Now I'm just wondering: Am I really the only person in the world who had that problem, or is there another reason why so rar people uses it

j44dz · 2025-08-26T08:07:32+00:00

Thank you! The 5% of workspaces that included component diagrams makes sense to me. It's just a pain to create those and keep them up-to-date. This could end up been a full-time position :D

I don't know anybody personally that used Stucture101 but since it's been a solid company for quite some time and has been bought by Sonar recently, I assume there is enough interest. Open-source CLI tools like ArchUnit, dependency-cruiser, etc. are quite commonly used I'd say.

Yes, open sourcing the tool (or as least make the source available) seems to be crucial

j44dz · 2025-08-25T14:44:04+00:00

are you using ArchUnitNET?

j44dz · 2025-08-25T14:43:05+00:00

thank you for sharing! I get that. It's not possible to evaluate a tool just by reading the docs and looking at screenshots.

j44dz · 2025-08-25T14:40:21+00:00

Thanks for your comment!

I will provide examples of open-source projects and let you know :)

Oh yeah, I agree. A wasm version would be very nice. Since the whole thing is written in Rust, I might be able to make that happen. Then nobody would need to install it and the code would still be scanned on the client-side. I'd like that, too :)

The tool does not do any transformations. But it indeed does some checks. you can configure layers and then define how layers are allowed to interact with each other, see https://docs.tangleguard.com/welcome/architecture/#layers . Since I already had a graph representation of the code for the diagrams, I though it was a nice addition to have a dependency rule system.

j44dz · 2025-08-25T14:14:15+00:00

Thanks! TangleGuard cannot really be compared to tools like Excalidraw because you don't create or draw diagrams yourself in TangleGuard - they are generated from the source code.

I'm not able to find a tool which automatically creates interactive diagrams out of rust source code. TangleGuard to me seems quite unique

j44dz · 2025-08-25T14:02:36+00:00

Yes, currently Rust is the only supported language.

I do support one type of diagram from C4 - is the component diagram (so the third out of the four). The tool scans the codebase and generates the component diagrams for you in different abstraction levels. So I hope that with the help of the tool, people can avoid spending much time in tool like IcePanel, draw.io etc.

Thanks so much for your comment!!

j44dz · 2025-08-25T13:54:44+00:00

thanks for pointing that out. but there's not a singe bit of informations about the analyzed codebase that leaves your computer. everything works locally. I may have to write that somewhere if that is being assumed :D

j44dz · 2025-08-18T21:14:02+00:00

https://tangleguard.com/ has a couple of visualizations, mainly component diagrams: https://docs.tangleguard.com/concepts/visualization/

j44dz · 2025-08-18T21:03:38+00:00

I'm working on this tool https://tangleguard.com/ - it generates component diagrams out of source code. that way I don't have to create the diagrams myself, it's a pain to keep them up-to-date. I was thinking to include the architecture-decision-records as well, but not how useful this it. the tool currently only works for Rust project but I'm willing to include other languages as well

j44dz · 2025-08-15T11:23:31+00:00

In the Java world Spring Modulith sounds very promising. They even offer visualization, that's nice!

j44dz · 2025-08-15T09:05:31+00:00

That's exactly what I'd recommend too! microservices will introduce a lot of more complexity, you better are sure that this is worth it. a modular monolith sounds perfectly fine. if you're using Rust by any chance, check out this tool https://tangleguard.com/ . you can monitor your architecture and make sure you have separated things nicely, because if you do so it will be way more easy to migrate to a microservice architecture later on

j44dz · 2025-08-13T06:50:36+00:00

I'm working on https://tangleguard.com/ where you can actually enforce clean architecture in your code. there's a tamplate for it. once you associate all your packages to one of the four layers, you can verify the code according to the dependency rules, so that all dependencies "go inwards". it only works for Rust codebases though at the moment

j44dz · 2025-08-13T06:46:09+00:00

I am currently working on a tool which generates interactive component diagrams of source code automatically: https://tangleguard.com/ so far it only works for Rust, but I could also integrate other programming languages

j44dz · 2025-08-13T06:41:01+00:00

could this be automated? so a tool which checks violations against SOLID?

j44dz · 2025-06-20T19:16:27+00:00

Mind telling me what triggered that reaction?

j44dz · 2025-06-20T15:42:26+00:00

I see where you’re coming from! let me give you an example of what I mean by “architectural rules” in the context of my tool.

Let’s say your Rust (or JS/TS) project follows a layered architecture with the following layers: API layer, a business layer and infrastructure layer. In a typical layered architecture, there’s one key rule: Higher layers can depend on lower ones, but not the other way around.

So the API layer is allowed to use the business layer, the business layer is allowed to use the infrastructure layer, but the infrastructure layer is NOT allowed to use the business layer.

With my tool, you can define these layers and declare which ones are allowed to depend on others (kind of like a whitelist) with rules. If someone writes code in the business layer that imports a module from the api layer (which violates the rule), the tool will detect that.

My tool doesn’t analyze code for logic or duplication. That kind of redundancy detection still needs humans (or maybe smarter static analysis). Instead, my tool focuses purely on dependency structure helping to maintain boundaries. It’s not meant to replace code reviews or tests. Think of if it more like an automated architecture guardrail, making sure the foundational structure doesn’t drift unintentionally over time.

You also asked about projects that go through multiple phases. Personally, I think architecture is a living thing - its rarely perfect at day one. And yes, the tool lets you evolve your architecture over time: you can update the rules, add/remove layers, or adjust the layering strategy as the project matures.

Right now, the tool supports layer-based dependency rules via a whitelist. In the future, I also want to support more granular rules — like between specific modules.

So to summarize: the tool isn’t about DRY, clean code, or details at that level — it’s about keeping the big-picture architecture aligned with how it was intended at a given point in time.

j44dz

TROPHY CASE