I'm no expert in GUI, but I think I could help you get in the right direction. I'm assuming that you want to avoid manually setting button sizes for each language, so this will discuss how to procedurally generate a GUI.

Depending on how you are rendering your fonts, there should be a way to get the width and height of a string. For instance, if you are using the Java swing library, [this][1] is how you could get the pixel dimensions of your text. Obviously, if you are using a different API, you will have to find this method on your own, or if you are writing your font rendering from scratch, you will have to implement this on your own. This shouldn't be too difficult so I won't get into the details of it. If you are concerned about a language's translation being really long and taking up too much screen space, here is where you could write some code that will check "Is this string length excessively long?" If so, shrink the font size.

The next step is to write a "procedural design" system. This basically takes the dimensions of the string from the previous step and then creates a button object based on that. Depending on how complex your game's GUI is, this could be either really easy or really difficult. Assuming you are using OpenGL, you can create a button of custom size by procedurally generating a VBO like this:

    /* Top Left */
    // Pos
    vertices[0] = -dimensions.x;
    vertices[1] = dimensions.y;
    // TexCoord
    vertices[2] = 0;
    vertices[3] = 0;

    /* Top Right */
    // Pos
    vertices[4] = dimensions.x;
    vertices[5] = dimensions.y;
    // TexCoord
    vertices[6] = 1;
    vertices[7] = 0;

    /* Bottom Right */
    // Pos
    vertices[8] = dimensions.x;
    vertices[9] = -dimensions.y;
    // TexCoord
    vertices[10] = 1;
    vertices[11] = 1;

    /* Bottom Left */
    // Pos
    vertices[12] = -dimensions.x;
    vertices[13] = -dimensions.y;
    // TexCoord
    vertices[14] = 0;
    vertices[15] = 1;
    
    elements[] = { 0, 1, 2, 2, 3, 0 };

Note: This assumes you are using glDrawElements(GL_TRIANGLES).

If you are concerned about getting the button to look interesting, remember that because of how texture coordinates work in OpenGL, the image will stretch to the size of the button. This usually works for when the buttons don't end up stretching too much, so the visual artifacts aren't very visible. However, if this produces too obvious of an effect, you can implement a more complicated texturing system so that you repeat the texture rather than stretching it. Or even make it so that you repeat the middle of the texture (the body of the button) but don't tile the ends of the button. This would probably produce the most natural effect, however it may not be necessary depending on the requirements of your GUI.

You can probably use similar code/techniques in applying this to other parts of your GUI system, but you will probably have to change how you calculate the dimensions if you are not making a button with text on it. Additionally, if you want a GUI element that changes size dynamically (eg a text box that expands as the player types), keep in mind you will have to dynamically rewrite the gui's vbo. Make sure you use GL_DYNAMIC_DRAW for dynamic elements.

Good Luck! Have fun coding and learning! [1]: https://stackoverflow.com/questions/258486/calculate-the-display-width-of-a-string-in-java