### Author:  [@Chrisir](https://discourse.processing.org/u/Chrisir)
#### Post date: [January 16, 2026, 11:11pm UTC](https://discourse.processing.org/t/rendering-animation-issue/47755/5 "2026-01-16T23:11:21Z")
> ```auto
> for (int i=0; i
> folder.render(pg);
>
> }
>
> ```
imho this gives you an infinite recursive loop. This is because you have folders within folders within folders within ….. etc. Bad.
you could insert an int depth variable and stop the recursion at depth 2 or so.
(Increment depth by every call to render() function)
May I ask what a Folder signifies in your project? A folder like in a file system?
---
### Author:  [@quark](https://discourse.processing.org/u/quark)
#### Post date: [January 17, 2026, 1:00pm UTC](https://discourse.processing.org/t/rendering-animation-issue/47755/6 "2026-01-17T13:00:24Z")
> [@AniManOtaku](#):
>
> If there are too many nested folders, there is a chance of getting an OhtOfMemoryError, which is unacceptable
When you call a function to be executed the computer will create a _ **stack frame** _ that will be pushed on to the processing stack.
The stack frame will store the following information
1. the function parameters
2. all local variables
3. the return address (where to find the next instruction once the function is finished)
Now in your program you are using recursion so lets assume the the top-level folder (F0) has the children, grand-children and great-grand-children as shown below
```
F0 ------ F1 ------ F11
| | F12 ------ F121
| | | F122
| | F13
|
--- F2 ------ F21
| F22
<< recursive depth = 4 >>
```
As the program executes we can trace the order of execution and see the state of the stack as each function is executed.
In each line the stack frame on the right identifies the function currently being executed. Noticed that the maximum stack frame depth is 4 and that every function is executed once.
```
STACK
Bottom <-------> Top
F0 F1 F11
F0 F1 F12 F121
F0 F1 F12 F122
F0 F1 F12
F0 F1 F13
F0 F1
F0 F2 F21
F0 F2 F22
F0 F2
F0
```
In your original code the `pg` was a local variable so that every frame contained its own `PGraphics` object and it would exist as long as the stack frame existed. So as the recursive depth increases the amount of memory increases rapidly which is why I made my previous suggestion.
Your recursive function will always terminate because eventually it will come across `Folder` objects with no children, in my example these are
```
F11 F121 F122 F13 F21 F22
```
So some things to strive for
- avoid creating memory hungry local variables
- avoid recreating images that have not changed
- lazy update when creating images
Without more detailed information I cannot really provide a more definitive answer but I hope this explanation will give you an insight into where you memory is being used. 🤓
---
### Author:  [@AniManOtaku](https://discourse.processing.org/u/AniManOtaku)
#### Post date: [January 17, 2026, 6:15pm UTC](https://discourse.processing.org/t/rendering-animation-issue/47755/7 "2026-01-17T18:15:39Z")
I understand. In my project, “folders” are not file system objects; this is simply class name. They can contain layers or other folders inside them. Layers, in turn, contain frame images. Layers and folders can have various filters, effects, overlays, etc.
Exemple:
---
### Author:  [@AniManOtaku](https://discourse.processing.org/u/AniManOtaku)
#### Post date: [January 17, 2026, 7:02pm UTC](https://discourse.processing.org/t/rendering-animation-issue/47755/8 "2026-01-17T19:02:37Z")
Actually, I don’t have any actual code yet. I’m just experimenting and thinking about how to write the code correctly so that there won’t be any difficulties later on. So i have nothing to share here.
It’s a little difficult for me to understand. Sorry, English is not my native language.
But it seems that you mean to make PG a global variable and render all folders to it. There is one problem related to the fact that each folder/layer has its own set of effects and filters. Therefore, I cannot render everything to one PG. But you can set a limit, for example, a maximum of two nested folders with effects. Then I can make two nested folders with effects/filters + an infinite number without.
Something like this:
```processing
class Folder {
ArrayList folders;
ArrayList layers;
Effect effect;
Filter filter;
String name;
PGraphics pg;
int folderDepth;
public Folder(String name, PGraphics canvas) {
this.name=name;
folderDepth=0;
}
public void addFilter(String filterType){
if(folderDepth<2){
//adding filter
}
}
public void createFolder(String path){
/*
create a folder at this path if it does not exist
and set folderDepth+1
*/
}
void render(PGraphics canvas) {
if(filter==null && effect==null){
for (int i=0; i
### Author:  [@quark](https://discourse.processing.org/u/quark)
#### Post date: [January 18, 2026, 10:20am UTC](https://discourse.processing.org/t/rendering-animation-issue/47755/9 "2026-01-18T10:20:33Z")
Ignore my last post it was simply to show how recursion works and things to avoid that might cause memory issues.
In your original post you created a new `PGraphics` object every time render was executed replacing the old `PGraphics` object. The problem is that the memory occupied by the old `PGraphics` object is is not _immediately_ released back to the system, instead it has to wait for Java’s garbage collection. So when using recursion many ‘old’ objects can remain in memory for some time causing out-of-memory errors. My reply was to create the graphics object once in the constructor and _ **reuse** _ it every time render is execute which is much more efficient.
If your sketch is not resizable then this code can be removed from the render function.
```java
if(pg.width != canvas.width || pg.height != canvas.height){
pg = createGraphics(canvas.width, canvas.height);
}
```
> [@AniManOtaku](#):
>
> But it seems that you mean to make PG a global variable and render all folders to it.
I wasn’t suggesting that sorry if I didn’t explain myself well.
> [@AniManOtaku](#):
>
> But you can set a limit, for example, a maximum of two nested folders with effects.
Looking at your original code it seems that a `Folder`’s graphic is some composite of all the graphics created in its sub-folders and sub-layers. If that is true then applying some recursive depth limit is _ **totally undesirable** _ and defeats the purpose of the application.
Provided the local variables in your render function do not require large amounts of RAM then recursion should not cause a memory problem.
Hope this makes things clearer. 🙂