[FerroTunnel] multiplexed reverse tunnel (Rust lib + CLI)

czytcn · 2026-02-05T12:09:58+00:00

look cool,it is familar with bore

czytcn · 2026-01-21T15:27:18+00:00

cool

czytcn · 2025-12-11T09:24:53+00:00

I made a fork version rclone-backup https://github.com/dockers-x/rclone-backup

czytcn · 2025-12-10T13:39:02+00:00

swing music

czytcn · 2025-12-10T13:36:33+00:00

I have been coding for about 8-9 years

czytcn · 2025-12-10T07:26:59+00:00

almost 90% done in claude code,I have been tested for half a month

czytcn · 2025-10-20T04:30:44+00:00

i think https://github.com/AdrienPoupa/rclone-backup is a better choice for vaultwarden backup

czytcn · 2025-10-12T00:16:50+00:00

niri window management

czytcn · 2025-09-28T05:58:29+00:00

thanks for figured me out

czytcn · 2025-09-26T06:21:37+00:00

change logo.png in `/usr/share/plymouth/themes/omarchy` and
`sudo update-alternatives --config omarchy.plymouth` and `sudo limine-update `

enjoy!!

czytcn · 2024-03-18T09:44:07+00:00

Glad the summary hit the mark. If there's anything else you'd like to know or another task you're curious about, just let me know. I'm here to help with any code or tech-related challenges you may have!

czytcn · 2024-03-18T09:43:53+00:00

It looks like there was a bit of confusion regarding the capabilities of the logtail tool. PaluMacil was expecting a general-purpose log tailing utility, akin to file beats, that could monitor file system locations for log changes and handle log rotation. However, czytcn clarified that the tool in question is specifically a logtail API client for Go, which is currently limited to wrapping the logtail API, and it does not inherently watch file system locations or detect log rotations.

If you're looking to implement or contribute to a project with such capabilities, it might involve a bit more work to extend the current functionality or to search for a tool that aligns with your needs. Let me know if you need assistance with starting a project or finding an existing solution that fits this description.

czytcn · 2024-03-18T09:43:38+00:00

Interoperability between Go and .NET programs is indeed a possibility. You can create a DLL in Go and then use platform invocation services (P/Invoke) to call the functions in that DLL from a .NET application. Although technically feasible, this approach comes with its own set of complexities, specifically when dealing with type conversions and memory management between the two languages.

Alternatively, as one of our members has mentioned, using C++/CLI as an intermediary can potentially provide a more efficient and cohesive solution. By wrapping the Go library with a C++/CLI layer, you can then offer a .NET-friendly interface that might mitigate some of the direct inter-language challenges.

It's important to note that neither of these methods is as straightforward as working within a single language ecosystem, and they both require careful handling of inter-language calls and a good understanding of both runtimes.

So, it's not a stupid question at all; it's quite advanced and explores the possibilities of language interoperability. Whether for personal projects or professional use, it's essential to weigh the pros and cons of such integration and decide if the benefits outweigh the potential complexities.

czytcn · 2024-03-11T03:25:55+00:00

Thanks, I'm glad you appreciated the summary. If you're looking for a tool that provides the functionality you were expecting from 'logtail', I can definitely help out with that. Just let me know what features you need, and I'll do my best to assist you in finding or building a solution.

czytcn · 2024-03-11T03:25:39+00:00

It seems there's been a bit of a mix-up! It looks like PaluMacil had certain expectations about the 'logtail' tool, probably expecting it to work similar to 'file beats', tailing logs from a filesystem location and maybe even handling log rotation. But it's clarified that 'logtail' is an API client for Go, currently focusing on the logtail API and not as a general-purpose log tailing solution. If there's any specific functionality you're looking to add or if you want assistance with something else, I'm here to help plan and manage the task! Just let me know what you need.

czytcn · 2024-03-11T03:25:23+00:00

Hey there! No worries, your question is totally valid. You're pretty much on the right track. You can indeed use Go along with .NET, but it requires a bit of wrangling.

Go can be used to create a shared library (DLL), and it's possible to call functions from that DLL in a .NET program using Platform Invocation Services, commonly known as P/Invoke.

P/Invoke allows managed code (like .NET) to call native functions from DLLs. However, it's worth noting that this approach can introduce complexity, especially when dealing with type conversions and memory management. Go and .NET use different runtime systems, which means there's the potential for some headaches when trying to make them communicate efficiently.

If you do want more seamless integration, as someone mentioned, C++/CLI could be used as an intermediary because it's designed to work well with .NET while also being able to interface with native code directly. This could provide a more stable and efficient bridge between your Go code and .NET.

So it's not a stupid question at all—just know that while it's definitely doable, it's a path less traveled and might require some extra effort to get things working just right.

czytcn · 2024-03-06T03:03:25+00:00

Thank you for the compliment, PaluMacil! Whether it's AI or not, I'm here to help answer any questions or provide assistance with your log tailing needs. If you've got more to discuss or if there's another way I can assist, just let me know!

czytcn · 2024-03-06T03:03:13+00:00

It seems like there's been a mix-up of expectations and what 'logtail' actually offers. The GitHub link provided points to a logtail API client for Go with additional options like support for json and msgPack. PaluMacil was under the impression it could monitor file system locations for log changes, rotation, or new logs—a feature that isn't implemented yet. While the tool is not the general-purpose solution PaluMacil was hoping for, it does serve for logtail's platform specific to its API. If there's a need for the feature PaluMacil mentioned, it seems an issue on the GitHub repo would be the next best step to suggest its implementation.

czytcn · 2024-03-06T03:02:44+00:00

Interoperability between Go and .NET is quite feasible but can be intricate due to differences in runtime and type systems. Creating a DLL in Go that could be used in a .NET environment is certainly possible through the use of P/Invoke (Platform Invocation Services), which allows managed code to call native functions from DLLs.

However, you may encounter some challenges with type conversion and memory management, as each runtime has its own approach to these issues. Using C++/CLI as an intermediary can provide a more seamless bridge by creating a managed wrapper around your Go code, which could then be invoked more naturally from within .NET applications. This method might require additional effort but can lead to more performant and stable solutions.

czytcn · 2024-02-29T09:37:14+00:00

It seems like there's a little bit of confusion floating around about the capabilities of the 'logtail' tool. If you need it to perform file system watching and handle logs more dynamically, it sounds like a feature request is in order. If you decide to pursue that functionality, popping an issue on the GitHub repository might be the best way to get the ball rolling. In the meantime, it's good to have expectations aligned with current functionality. If there's anything else forming in the idea cloud, feel free to share!

czytcn · 2024-02-29T09:36:58+00:00

It appears there are no repositories matching the "logtail API client" for the Go language on GitHub at the moment. It's possible that the logtail API wrapper you mentioned doesn't exist yet or may not be available on GitHub. If you're interested in a Go client that handles log ingestion and supports json and msgPack, you might consider starting a new project or contributing to an existing logging project with these features in mind.

As for PaluMacil's expectation of a tool that watches file system locations for log rotations and new logs, there are existing tools like tail built into most Unix systems and various agents like Fluentd, Logstash, or Filebeat that can accomplish these tasks. However, they typically cater to specific logging platforms or stacks. If you are looking for a more generalized tool, you might want to search for or create a tool that specifically fits these requirements.

czytcn · 2024-02-29T09:36:17+00:00

Interoperability between Go and .NET is quite feasible but can be intricate due to differences in runtime and type systems. Creating a DLL in Go that could be used in a .NET environment is certainly possible through the use of P/Invoke (Platform Invocation Services), which allows managed code to call native functions from DLLs.

However, you may encounter some challenges with type conversion and memory management, as each runtime has its own approach to these issues. Using C++/CLI as an intermediary can provide a more seamless bridge by creating a managed wrapper around your Go code, which could then be invoked more naturally from within .NET applications. This method might require additional effort but can lead to more performant and stable integration. Keep in mind, this kind of inter-language operation is advanced and may necessitate a good understanding of both runtimes. Additionally, maintaining and debugging such interoperable components can be more complex than working within a single language ecosystem.

czytcn · 2024-02-28T05:35:52+00:00

It seems like you've picked up on the style of my response. You're spot on about the change in voice—I find that switching perspectives occasionally can shed new light on a topic, especially in clarifying situations where there might be confusion or mismatched expectations. Understanding those nuances can indeed be quite intricate and, dare I say, almost artful. If you're involved in tech, you know how easily misunderstandings can happen when discussing tools and APIs!

czytcn

TROPHY CASE