Hello There,

a feature i wish VBA had was a way to write in a functional programming paradigm.

Since this is not the case i tried to at least provide First Class Functions with the ability to bind arguments to it.

I know that someone already did something like that but i just cannot for the live of me find it.

So i made my own:

Almesi/VBFP: Visual Basic Functional Programming

Does anyone have Input on it?

Anything i should add or redo in a different, more robust way?

I would love to implement immutability after creation but i dont know how while still being able to create it with a constructor.

In have a table of data in Excel which represents a nested hierarchical structure. The rows are elements in the structure. All elements are five elements deep. The first five columns of the table represent the level/position of the element. For example, column “Level 1” might have a value of "1", "Level 2” a value of “1.1”, and so on, with the fifth column representing the final element (1.1.1.1.1, 1.1.1.1.2, etc). The other columns describe the names, descriptions of the elements.

I am trying to use VBA to loop through these nested elements with the ultimate goal of creating some documentation of this structure within a Word document with additional notes, etc, in a consistent style.

I have created a PivotTable, which may or not be helpful to my outcome, but it does at least let me see the structure of the parent/child elements. Copying this data into Word from the PivotTable does not make it easy to edit or read which is why I am trying to reconstruct it.

My VBA code is below but of course, it outputs the rows from the columns, rather than the parent item they are from. Maybe there is a better approach altogether! Thank you for any guidance

For Each ptItem In pt.PivotFields("Level 1").PivotItems
  Debug.Print ptItem
    For Each ptItem2 In pt.PivotFields("Level 2").PivotItems
      Debug.Print ptItem2.Name
        For Each ptItem2 In pt.PivotFields("Level 3").PivotItems
          Debug.Print ptItem2.Name
        Next
    Next
Next

vbaXray is a single VBA class module that extracts VBA source code straight out of Office files.

I posted about v1.0 a few months back, but a thread earlier this week (here) reminded me that I still hadn't uploaded the updated v2.0 to GitHub. Life gets in the way, but here it is.

I give you vbaXray v2.0. In short, it:

• Slices and dices
• Extracts vbaProject.bin directly from OOXML files. XLSM, DOCM, PPTM, etc are ZIP files, and thanks to the long-standing work of the VB6/TwinBasic community (especially u/Fafalone), v2 uses the ZipFldr IStorage route to pull the data straight out as a byte array. No temp files. No Shell.Application. Much faster than v1.0.
• Supports older Office formats. XLS and DOC were straightforward. PPT was not. PPT was a fever dream. The babushka doll from hell. A cursed nesting doll of compressed records, undocumented structures, and pure spite. OLEVBA at least pointed me to where the VBA was hiding.
• Supports ACCDB and MDB. For this, thanks to u/MultiUserDungeonDev and the pyOpenVBA project (see here for original reddit post) for demonstrating how Access stores VBA across database pages.
• Adds diagnostics. DebugDumpStorageTree prints the internal OLE storage tree to the Immediate window (or a file). If a file should work but doesn't, this shows exactly what's inside the CFB.

​

Sub XrayDemo()
  Dim xray As New clsVBAXray
  If xray.LoadFromFile("C:\Suspicious\LegacyMacro.doc") Then
    Debug.Print "Project: " & xray.ProjectName
    Debug.Print "Modules: " & xray.ModuleCount
    xray.ExportAll "C:\OutputCodeHere\ExtractedCode\"
    xray.DebugDumpStorageTree
  Else
    Debug.Print "Load failed: " & xray.LastError
  End If
End Sub 

I hope that someone finds this helpful. There are plenty of use cases (malware analysis, bulk auditing, source control extraction), and if it is useful, please let me know. As always, questions, suggestions, and feedback are encouraged and always appreciated.

Code, some basic documentation (for now), and a (very simple) demo workbook are already on GitHub: https://github.com/KallunWillock/vbaXray/

I became curious about how far I could push AI, so I decided to see if it was possible to do web scraping using Excel VBA alone, with absolutely no WebDriver.exe or other external dependencies. I wanted to find out if I could bring back that “magic from the old days” — where, just by writing some code, the browser would actually work without having to install anything extra, like we used to be able to do with the old IEObject. 🥺

My workplace has very strict security policies, so I can't install WebDriver.exe, Python, Node.js, etc. However, VBA is allowed. So I kept having conversations with AI, trying to figure out whether there was some way to control Chromium using VBA alone. 🫠

I had AI read through the source code of Google's rather complicated [chromium-bidi] (WebDriver BiDi) and asked whether its logic could be reproduced in VBA. VBA doesn't have built-in WebSocket support or multithreading, but AI suggested some modern design ideas, such as WinSock and an event-driven model using WithEvents.

And surprisingly, I was able to do quite a lot without having to install Playwright or Puppeteer. For example, I managed to control 10 tabs concurrently, control a browser on an Android smartphone, and achieve relatively better stealth against bot detection compared with SeleniumVBA, among other things. And the crazy part is that all of this is contained in a single Excel file.

What I like most is that whenever there is a feature I need, AI can quickly create it for me. Personally, I'm extremely satisfied with the result.🥹 At this point, I feel like this has evolved beyond being just a “macro” — it has become a core engine that can keep evolving by itself.🥳

You can check out the result of this journey (GitHub) below.

I'm Japanese, so you'll notice quite a lot of Japanese strings scattered throughout the source code, but I believe the underlying logic I built is quite sophisticated and I'm proud of how it turned out! https://github.com/Eschamali/StarterWebScrapingKit

I've been working on a side project to see how far a serious HTTP client can be pushed inside Excel/VBA.

It started with a fairly simple thought:

>Maybe I can build something nicer than the usual thin wrapper around WinHttpRequest.

It escalated quite a bit from there.

The result is VBA-HTTP, an HTTP client for Windows written in VBA:

https://github.com/harumiWeb/VBA-HTTP

It covers the usual things you'd expect from an HTTP client — requests and responses, headers, query parameters, and text/binary bodies — but I wanted to push it quite a bit further.

Some of the more unusual parts are:

• bounded concurrent requests
• a native winhttp.dll backend in addition to WinHttp.WinHttpRequest.5.1
• streaming multi-GB downloads and uploads without buffering the entire payload in VBA memory
• streaming multipart uploads
• retries with exponential backoff, jitter, and Retry-After
• deadlines and cancellation
• Basic, Bearer, and Windows challenge authentication
• proxy support and an explicit cookie jar
• HTTP/2 protocol control and reporting through native WinHTTP
• deterministic WinHTTP handle and resource cleanup

The API is intended to feel more like an HTTP client from a modern language than a collection of raw COM calls.

Dim client As HttpClient
Dim request As HttpRequest
Dim response As HttpResponse

Set client = VBAHttp.CreateClient()
Set request = VBAHttp.CreateRequest()

request.Method = "GET"
request.Url = "https://example.com/items"
request.Query.Add "page", 1
request.Query.Add "limit", 100

Set response = client.Execute(request)
response.RaiseForStatus

Debug.Print response.Text

It also supports bounded concurrency across multiple independent requests:

Dim urls As New Collection
Dim options As New HttpBatchOptions
Dim result As HttpBatchResult

urls.Add "https://example.com/a"
urls.Add "https://example.com/b"
urls.Add "https://example.com/c"

options.MaxConcurrency = 8

Set result = client.GetMany(urls, options)

Debug.Print result.SuccessCount
Debug.Print result.FailureCount

For example, against a deterministic local test server where each of 100 requests waits for 100 ms:

Sequential       11.04 s
Concurrency 16    0.86 s

12.86x faster

Obviously this is a deliberately latency-heavy benchmark. I'm not claiming that every HTTP workload becomes 12.86x faster.

The benchmark methodology and raw results are included in the repository.

Large transfers were another area I wanted to push.

VBA-HTTP can stream a 1 GiB download without representing the entire payload as a 1 GiB VBA Byte() array.

In one recorded x64 Excel baseline run, the transfer showed approximately 19 MB of peak private-memory growth.

It can also stream 1 GiB file uploads and multipart uploads incrementally through native WinHTTP.

More recently I've also been optimizing the native hot path itself — reusing fixed buffers, reading directly with WinHttpReadData, pre-sizing known-length buffered responses, and removing VBA byte-by-byte copies.

I deliberately stopped short of things like generated machine code or executable-memory tricks.

The native implementation only uses documented Windows APIs. I still want this to be something people could reasonably use, rather than just a VBA black-magic demo.

The other thing I wanted to push: testing

I didn't want the verification story for this project to be:

>"It works on my machine."

The repository has automated unit, integration, stress, resource, and release-validation tests, running against real Excel and a deterministic local HTTP/HTTPS server.

Among other things, the test suite exercises:

• 1 GiB download and upload with content/hash verification
• a 10,000-request resource and WinHTTP handle stability run
• repeated cancellation and timeout cleanup
• bounded-concurrency behavior
• retry and Retry-After behavior
• proxy and authentication fixtures
• HTTP/2 capability and negotiated-protocol validation
• release checksum and tamper validation
• real VBE compilation

A lot of VBA libraries understandably rely heavily on example workbooks and manual verification.

For this project, I wanted the behavior to be reproducible and machine-verifiable in roughly the same way I'd expect from a library in another language.

And there's one other slightly unusual part of the project:

I didn't manually write a single line of the implementation code.

I designed the architecture, requirements, acceptance criteria, benchmarks, and overall direction, but the implementation itself was written by coding agents operating through xlflow, the VBA development environment I've been building.

The agents worked on normal VBA source files, ran static analysis, compiled the project in real Excel, executed tests, inspected failures, modified the implementation, and repeated that feedback loop.

At one point I was literally away on vacation while the agent workflow continued building out the project.

About xlflow:

https://github.com/harumiWeb/xlflow

I originally built xlflow because I wanted coding agents working on VBA to have the same kind of:

edit → compile → test → analyze → fix

feedback loop that they get in more modern ecosystems.

VBA-HTTP ended up becoming a much more demanding dogfooding project than I originally expected.

So the project effectively became two experiments at once:

1. How far can networking and performance be pushed in VBA while keeping the result reasonably practical?
2. How complex a VBA project can coding agents build if they're given proper engineering feedback loops?

I'd be interested in feedback on either side.

And if anyone tries VBA-HTTP against a real API, corporate proxy, authentication setup, or weird HTTP server and manages to break it, I'd especially like to hear about it.

¡Hola a todos!

Quería compartir un proyecto personal(algo sencillo) en el que he estado trabajando y que espero pueda ser de utilidad para quienes, como yo, prefieren organizar sus flujos de trabajo de manera puramente local y sin depender de servicios externos.

El Problema que quería resolver
Necesitaba una herramienta para organizar mis proyectos diarios, pero las apps tradicionales requieren conexión a internet, cuentas de usuario y planes de suscripción.

Para solucionarlo, decidí desarrollar una plantilla en LibreOffice Calc gestionada únicamente por macros en Basic.

Al estructurar el archivo con un enfoque de base de datos, obtuve un sistema privado y del cual tengo control total:

• Funciona 100% fuera de línea (offline).
• No hay telemetría,
• no hay registros ni servidores de terceros
• los datos permanecen estrictamente dentro de su computadora en un archivo .ods.

Enlace al proyecto (Código Abierto)
He subido la plantilla y todo el código de las macros a un repositorio de GitHub bajo licencia MIT para que cualquiera pueda usarlo como quieran sin restricciones.

LINK👉: https://github.com/cesardev-1/canban

Nota: Actualmente se encuentra en version beta, pero es totalmente funcional, yo mismo lo utilizo a diario. Muy pronto estará recibiendo actualizaciones para llegar a la v1.0.

Agradezco de antemano cualquier sugerencia, crítica constructiva o reporte de error para seguir puliendo la herramienta. ¡Espero que les sea de utilidad!