Prompt Templates and Variables

# Purpose: Translate content into the selected language
Translate the following content from {source_language} to {target_language}.
Preserve the original meaning.
Use a {tone} tone.
Content: {content}

# Purpose: Translate an English message into Marathi
Translate the following content from English to Marathi.
Preserve the original meaning.
Use a friendly tone.
Content: Welcome to our programming course.

# Purpose: Create a controlled multilingual response
Task: {task}
Source language: {source_language}
Target language: {target_language}
Target region: {target_region}
Target audience: {target_audience}
Tone: {tone}
Formality level: {formality_level}
Preserve these terms: {preserve_terms}
Follow these terminology rules: {terminology_rules}
Output format: {output_format}
Process the following content.
Content: {content}
Preserve the original meaning.
Do not add unsupported information.
Explain any term that cannot be translated naturally.

Explain dependency injection in Marathi.

# Purpose: Generate an explanation in the selected language
Explain {topic} in {target_language}.
Use {script} script.
Write for {target_audience}.
Use a {tone} tone.
Keep technical terms in {technical_term_language}.
Output format: {output_format}

Explain this in my language.

# Purpose: Explain a programming concept in Marathi
Explain the following concept in Marathi using Devanagari script.
Keep Java class names, method names, annotations, and keywords in English.
Write for beginner Java developers.
Concept: Dependency Injection

# Purpose: Control the response language
Respond only in {target_language}.
Use {target_script} script.
Use the {regional_variant} regional variation.
Keep these terms unchanged: {preserve_terms}.
Do not switch to another language unless required for preserved terms.
User request: {user_request}

# Purpose: Translate content between two languages
Translate the following content from {source_language} to {target_language}.
Use a {translation_style} translation style.
Write for {target_audience}.
Preserve the original meaning.
Preserve the original formatting.
Do not add new information.
Content: {content}

Translate the content as closely as possible to the original words and sentence structure.

Translate the meaning naturally instead of translating each word separately.

The application failed because the database connection timed out.

डेटाबेस कनेक्शनची वेळ संपल्यामुळे ॲप्लिकेशन अयशस्वी झाले.

# Purpose: Translate a structured article
Translate the following article from {source_language} to {target_language}.
Preserve all headings, numbered lists, bullet points, and paragraph breaks.
Do not translate code, URLs, file paths, variable names, or product names.
Use terminology suitable for {target_audience}.
Article: {content}

Confirm that every source section has been translated.
Confirm that no new facts have been added.
Confirm that names and numerical values remain unchanged.
Confirm that preserved terms remain unchanged.
Return only the final translation.

The deployment may fail if the environment variable is missing.

# Purpose: Preserve meaning during translation
Translate the content from {source_language} to {target_language}.
Preserve the exact intent, facts, conditions, certainty level, and logical relationships.
Do not strengthen or weaken claims.
Do not add assumptions.
Do not remove warnings, exceptions, limitations, or conditions.
Keep names, dates, numbers, units, and identifiers unchanged.
Content: {content}

# Purpose: Verify a translation against its source
Compare the source content and translated content.
Identify any missing meaning.
Identify any added meaning.
Identify any changed facts.
Identify any changed certainty level.
Identify any changed tone that affects the intent.
Return corrected translation after the analysis.
Source content: {source_content}
Translated content: {translated_content}
Target language: {target_language}

We are sorry that you experienced this problem.

# Purpose: Preserve tone during translation
Translate the following content from {source_language} to {target_language}.
Preserve the original {tone} tone.
Preserve the same level of emotion, politeness, urgency, and formality.
Use natural expressions for the target language.
Do not make the message more aggressive, casual, emotional, or formal than the original.
Content: {content}

# Purpose: Detect and preserve the original tone
Identify the tone of the source content.
Translate the content from {source_language} to {target_language}.
Preserve the detected tone and level of formality.
Use natural phrasing for the target audience.
Do not explain the detected tone.
Return only the translated content.
Content: {content}

# Purpose: Translate content using a new tone
Translate the following content from {source_language} to {target_language}.
Preserve the original meaning.
Change the tone to {target_tone}.
Write for {target_audience}.
Do not change facts, names, dates, numbers, or instructions.
Content: {content}

Send the report today.

कृपया आज अहवाल पाठवा.

# Purpose: Translate technical documentation accurately
Translate the following technical content from {source_language} to {target_language}.
Technical domain: {technical_domain}.
Target audience: {target_audience}.
Use the provided terminology glossary.
Keep programming keywords, class names, method names, variable names, annotations, API names, commands, file paths, and URLs unchanged.
Preserve all code, numbers, units, warnings, and formatting.
Do not simplify technical meaning unless explicitly requested.
Do not guess the meaning of unknown terms.
Glossary: {terminology_glossary}
Content: {content}

# Purpose: Translate Java documentation into Marathi
Translate the following Java documentation from English to Marathi.
Write for beginner Java developers.
Keep Java, JVM, JDK, class, interface, object, method, constructor, extends, implements, public, private, and protected in English.
Keep all code unchanged.
Explain difficult English technical terms in Marathi when first used.
Preserve headings and bullet points.
Content: {content}

# Purpose: Translate text without modifying code
Translate only the explanatory text into {target_language}.
Do not translate or modify content inside code sections.
Do not change indentation.
Do not change identifiers.
Do not change string values unless they are user-facing messages.
Do not change comments unless {translate_comments} is set to yes.
Content: {content}

# Purpose: Localise content for a target market
Localise the following content for {target_locale}.
Target language: {target_language}.
Target region: {target_region}.
Target audience: {target_audience}.
Adapt dates, times, currency, measurements, address formats, examples, and cultural references.
Preserve the original business intent.
Do not change product features or factual claims.
Keep brand names unchanged.
Explain any major localisation decision that may affect meaning.
Content: {content}

# Purpose: Localise marketing content for India
Localise the following content for English-speaking customers in India.
Use Indian English.
Display prices in Indian rupees.
Use lakh and crore where appropriate.
Use the DD/MM/YYYY date format.
Use examples familiar to Indian customers.
Keep the brand name and product name unchanged.
Content: {content}

# Purpose: Localise application labels
Translate and localise the following user-interface labels for {target_locale}.
Keep each label short.
Use common application terminology.
Preserve placeholder variables such as {username}, {date}, and {amount}.
Do not translate brand names.
Return the result as a two-column Markdown table.
Labels: {ui_labels}

# Purpose: Convert text between writing scripts
Transliterate the following text from {source_script} to {target_script}.
Preserve pronunciation as closely as possible.
Do not translate the meaning.
Keep names, numbers, and punctuation unchanged unless script conversion requires a change.
Text: {content}

# Purpose: Convert Marathi text into readable Latin script
Transliterate the following Marathi text from Devanagari to Latin script.
Preserve natural Marathi pronunciation.
Do not translate the text into English.
Use simple spellings that Marathi speakers can easily read.
Text: {content}

# Purpose: Convert Latin-script Marathi into Devanagari
Convert the following Marathi text written in Latin script into Devanagari.
Preserve the intended Marathi words.
Correct obvious phonetic spelling differences when the intended word is clear.
Do not translate the content.
Mark uncertain words using square brackets.
Text: {content}

If a word has more than one possible Devanagari form, select the form that best matches the sentence context.
If the correct form cannot be determined, keep the original word and mark it as uncertain.

# Purpose: Generate a bilingual explanation
Explain {topic} in {language_one} and {language_two}.
Create a separate section for each language.
Keep both sections equal in meaning and detail.
Use the same examples in both sections.
Preserve technical terms in English.
Output format: Markdown.

# Purpose: Present each sentence in two languages
Write the response in {language_one}.
Place the {language_two} translation immediately below each sentence.
Preserve the same meaning and tone.
Do not combine multiple source sentences into one translated sentence.
Topic: {topic}

# Purpose: Create a bilingual reference table
Explain {topic} in {language_one} and {language_two}.
Return a two-column Markdown table.
Use {language_one} in the first column.
Use {language_two} in the second column.
Keep each row focused on one concept.
Preserve technical terms where necessary.

# Purpose: Teach a technical concept bilingually
Explain {technical_topic} first in English and then in Marathi.
Write for beginner developers.
Keep Java keywords and code in English.
Use the same explanation structure in both languages.
Include one practical example.
Do not remove details from the Marathi section.
Output format: Markdown.

Explain Java inheritance in Marathi, पण code example English मध्ये ठेवा.

# Purpose: Control language use in a mixed-language response
Use {primary_language} as the main response language.
Use {secondary_language} only for {secondary_language_purpose}.
Keep technical terms in {technical_term_language}.
Do not mix languages inside the same sentence unless required for a technical term.
Use {target_script} script for the primary language.
User request: {user_request}

# Purpose: Generate a controlled Marathi-English explanation
Write the explanation mainly in Marathi using Devanagari script.
Keep programming keywords, class names, method names, commands, and code in English.
Use English technical terms when a common Marathi term is not available.
Explain difficult English terms in Marathi when first used.
Do not write complete explanatory paragraphs in English.
Topic: {topic}

# Purpose: Understand and normalise mixed-language input
Read the following mixed-language input.
Identify the main request.
Rewrite the request in clear {normalised_language}.
Preserve all technical terms, names, numbers, and constraints.
Do not answer the request.
Return only the normalised request.
Input: {mixed_language_input}

# Purpose: Use a specific regional language variation
Write the response in {language}.
Use the {regional_variant} regional variation.
Follow regional spelling, vocabulary, grammar, date format, number format, and common expressions.
Avoid words that are uncommon or misleading in the target region.
Write for {target_audience}.
Topic: {topic}

# Purpose: Write content using Indian English
Write the content in clear Indian English.
Use spellings commonly accepted in India.
Use Indian date, currency, and number formats where relevant.
Use lakh and crore for large Indian numbers when appropriate.
Avoid region-specific American expressions that may confuse Indian readers.
Content topic: {topic}

# Purpose: Create widely understandable Marathi content
Write the response in standard Marathi using Devanagari script.
Use vocabulary that is commonly understood across Maharashtra.
Avoid highly local expressions unless {target_region} requires them.
Keep technical terms in English where Marathi alternatives sound unnatural.
Topic: {topic}

# Purpose: Adapt content to the target culture
Adapt the following content for {target_culture}.
Preserve the original purpose and key message.
Replace unfamiliar cultural examples with suitable local examples.
Use culturally appropriate greetings, politeness, humour, and references.
Avoid stereotypes and unsupported assumptions.
Do not change factual claims or product features.
Explain any reference that should remain unchanged.
Content: {content}

# Purpose: Translate with cultural awareness
Translate the content from {source_language} to {target_language}.
Target culture: {target_culture}.
Preserve the original meaning and tone.
Replace idioms with natural expressions that communicate the same idea.
Do not translate idioms word by word when the result would be confusing.
Avoid culturally unsuitable jokes or examples.
Content: {content}

Break the ice.

Replace each idiom with a natural target-language expression that communicates the same intended meaning.
Do not preserve the original words when a literal translation would sound unnatural.
Keep the original idiom in parentheses only when educational context requires it.

# Purpose: Enforce approved terminology
Translate the content from {source_language} to {target_language}.
Use the approved glossary exactly.
Use the same approved term every time the same source term appears.
Do not replace approved terms with synonyms.
Keep terms listed as unchanged in their original form.
If a term is missing from the glossary, translate it naturally and add it to the new-terms list.
Approved glossary: {terminology_glossary}
Terms to preserve: {preserve_terms}
Content: {content}

# Purpose: Check terminology consistency
Review the following translated content.
Compare every technical term against the approved glossary.
Identify inconsistent translations.
Identify translated terms that should remain unchanged.
Correct all terminology inconsistencies.
Return the corrected content followed by a short correction summary.
Approved glossary: {terminology_glossary}
Translated content: {translated_content}

Dependency Injection म्हणजे डिपेंडन्सी इंजेक्शन ही object dependencies देण्याची पद्धत आहे.

On first use, write each technical term as {english_term} followed by its {target_language} explanation.
On later uses, use only the approved English technical term.

# Purpose: Handle terms without exact translations
Translate the following content from {source_language} to {target_language}.
When a term has no accurate translation, keep the original term unchanged.
Add a short explanation in {target_language} after its first use.
Do not invent a new translation.
Do not replace a precise term with a broader or weaker term.
Add uncertain terms to a review list.
Content: {content}

# Purpose: Mark uncertain translation decisions
Translate the content into {target_language}.
Mark any term with uncertain meaning using [REVIEW: original term].
Provide up to three possible interpretations below the translation.
Do not silently guess.
Content: {content}

The application uses dependency injection.

हे ॲप्लिकेशन Dependency Injection म्हणजे आवश्यक dependencies बाहेरून देण्याची पद्धत वापरते.

Keep all company names, product names, trademarks, API names, package names, library names, and framework names unchanged.

Keep common abbreviations such as API, URL, HTTP, JVM, SQL, and JSON unchanged.
Explain an abbreviation in the target language only when it first appears and the audience may not know it.

# Purpose: Generate a controlled multilingual response
Task: {task}
Input language: {input_language}
Output language: {output_language}
Output script: {output_script}
Regional variation: {regional_variant}
Target audience: {target_audience}
Tone: {tone}
Formality level: {formality_level}
Keep these terms unchanged: {preserve_terms}
Follow this glossary: {terminology_glossary}
Output format: {output_format}
Perform the requested task.
Preserve all names, dates, numbers, and technical identifiers.
Do not add unsupported information.
Input: {input_content}

# Purpose: Translate content accurately
Translate the content from {source_language} to {target_language}.
Use the {regional_variant} regional variation.
Use a {translation_style} translation style.
Preserve the original meaning and {tone} tone.
Write for {target_audience}.
Preserve headings, lists, tables, and paragraph structure.
Keep these terms unchanged: {preserve_terms}.
Use this glossary: {terminology_glossary}.
Do not add, remove, or change facts.
Content: {content}

# Purpose: Translate technical content
Translate the following {technical_domain} content from {source_language} to {target_language}.
Write for {target_audience}.
Preserve technical accuracy.
Keep code, commands, keywords, class names, method names, variables, file paths, URLs, API names, and product names unchanged.
Preserve numbers, units, warnings, and formatting.
Use the approved glossary exactly.
Mark uncertain terms for review.
Approved glossary: {terminology_glossary}
Content: {content}

# Purpose: Localise content for a specific region
Localise the following content for {target_locale}.
Target language: {target_language}.
Target country or region: {target_region}.
Target audience: {target_audience}.
Adapt currency, date format, time format, measurements, examples, addresses, and cultural references.
Preserve the original intent, facts, and product details.
Keep brand names and technical identifiers unchanged.
Output format: {output_format}.
Content: {content}

# Purpose: Preserve communication style
Translate the following content from {source_language} to {target_language}.
Preserve the original tone, emotion, politeness, urgency, and formality.
Use natural expressions for {target_region}.
Do not make the message stronger, weaker, friendlier, harsher, or more formal than the original.
Preserve all facts and conditions.
Content: {content}

# Purpose: Explain a topic in two languages
Explain {topic} in {language_one} and {language_two}.
Present the {language_one} section first.
Present the {language_two} section second.
Keep both sections equal in meaning and detail.
Use the same examples in both sections.
Keep technical terms in {technical_term_language}.
Write for {target_audience}.
Output format: Markdown.

# Purpose: Control language mixing
Use {primary_language} as the main language.
Use {secondary_language} only for {secondary_language_purpose}.
Use {primary_script} for the primary language.
Keep technical terms in {technical_term_language}.
Do not switch languages unnecessarily.
Do not mix languages inside one sentence unless required for technical clarity.
Topic: {topic}

# Purpose: Convert text between scripts
Transliterate the following content from {source_script} to {target_script}.
Preserve pronunciation.
Do not translate the meaning.
Use spelling suitable for {target_audience}.
Keep numbers, names, and punctuation unchanged where possible.
Mark uncertain words for review.
Content: {content}

# Purpose: Maintain terminology consistency
Process the following content in {target_language}.
Use the approved glossary exactly.
Use one approved term for each concept.
Do not replace approved terms with synonyms.
Keep protected terms unchanged.
Add missing technical terms to a separate review list.
Approved glossary: {terminology_glossary}
Protected terms: {preserve_terms}
Content: {content}

# Purpose: Summarise content in another language
Read the following content written in {source_language}.
Create a summary in {target_language}.
Preserve the main facts, decisions, names, dates, numbers, and conclusions.
Use a {tone} tone.
Write for {target_audience}.
Limit the summary to {word_limit} words.
Keep technical terms in {technical_term_language}.
Content: {content}

# Purpose: Answer a question in the requested language
Read the question written in {input_language}.
Answer in {output_language}.
Use {output_script} script.
Write for {target_audience}.
Preserve technical terms in {technical_term_language}.
Do not translate code, commands, class names, method names, file paths, or URLs.
State clearly when the provided information is insufficient.
Question: {question}
Reference information: {reference_content}

# Purpose: Generate original content for a target language
Create a {content_type} in {target_language}.
Target region: {target_region}.
Target audience: {target_audience}.
Tone: {tone}.
Formality level: {formality_level}.
Length: {length_requirement}.
Include these points: {required_points}.
Avoid these elements: {excluded_elements}.
Use this terminology glossary: {terminology_glossary}.
Keep these terms unchanged: {preserve_terms}.
Output format: {output_format}.

# Purpose: Create a localised support response
Read the customer message written in {customer_language}.
Respond in {response_language}.
Use a respectful and empathetic tone.
Preserve product names, order numbers, dates, and technical identifiers.
Explain the next steps clearly.
Do not promise actions that are not included in the support policy.
Use the terminology suitable for {customer_region}.
Customer message: {customer_message}
Support policy: {support_policy}

# Purpose: Teach a concept in the learner's preferred language
Explain {topic} in {target_language}.
Use {target_script} script.
Write for {learner_level} learners.
Keep technical terms in {technical_term_language}.
Define difficult terms in simple language.
Include one real-life example.
Include one technical example.
Include a short summary.
Do not assume prior knowledge beyond {prerequisites}.

# Purpose: Explain source code in another language
Explain the following {programming_language} code in {target_language}.
Keep all code, keywords, identifiers, class names, method names, and variable names unchanged.
Explain the purpose of each important section.
Explain the execution flow step by step.
Define technical terms in simple language.
Write for {target_audience}.
Code: {code}

# Purpose: Review code using a selected output language
Review the following {programming_language} code.
Write the review in {target_language}.
Keep code and technical identifiers in English.
Identify correctness issues.
Identify security risks.
Identify performance issues.
Identify maintainability problems.
Suggest corrected code when required.
Explain every suggestion in simple language.
Code: {code}

# Purpose: Generate Java code with multilingual explanation
Generate Java code for {requirement}.
Use Java version {java_version}.
Write code, identifiers, and comments in English.
Write the explanation in {target_language}.
Follow {coding_standard} coding standards.
Include input validation.
Include error handling.
Do not use external libraries unless listed in {allowed_libraries}.
Return the code first and the explanation second.

# Purpose: Generate Python code with a local-language explanation
Generate Python code for {requirement}.
Use Python version {python_version}.
Write code and identifiers in English.
Write the explanation in {target_language}.
Follow PEP 8 naming and formatting rules.
Include input validation.
Include error handling.
Do not use external packages unless listed in {allowed_packages}.
Return the code first and the explanation second.

# Purpose: Generate SQL with multilingual guidance
Generate a {database_type} SQL query for {requirement}.
Write the SQL query in standard SQL syntax.
Write the explanation in {target_language}.
Preserve table names and column names exactly.
Do not assume columns that are not included in the schema.
Explain joins, filters, grouping, and ordering.
Database schema: {database_schema}

# Purpose: Validate multilingual prompt variables
Verify that all required variables contain valid values.
Check that the source language and target language are supported.
Check that the target script is compatible with the target language.
Check that terminology rules do not conflict.
Check that preserved terms are not included in the translation glossary.
Report missing or conflicting values before processing the content.
Variables: {variable_values}

If {tone} is missing, use a neutral tone.
If {regional_variant} is missing, use the standard variation of {target_language}.
If {target_script} is missing, use the most common script for {target_language}.
If {terminology_glossary} is empty, use common domain terminology.
If the target language is unclear, request clarification instead of guessing.

# Purpose: Apply optional multilingual controls
Translate the content into {target_language}.
Include the source text when {include_source} is yes.
Add transliteration when {include_transliteration} is yes.
Translate code comments when {translate_comments} is yes.
Convert regional formats when {localise_formats} is yes.
Explain technical terms when {explain_terms} is yes.
Content: {content}

# Purpose: Resolve conflicting multilingual requirements
Review the supplied variables before performing the task.
Treat meaning preservation as the highest priority.
Treat approved terminology as the second priority.
Treat target-language grammar and naturalness as the third priority.
Treat tone and style as the fourth priority.
Treat formatting preferences as the fifth priority.
Report any conflict that cannot be resolved without changing meaning.
Variables: {variable_values}

Write in the local language.

Write in standard Marathi using Devanagari script.

Translate and change everything for India.

Translate the content into Indian English.
Adapt dates, currency, and examples for India.
Preserve all product features and factual claims.

Translate everything into Marathi.

Translate explanatory text into Marathi.
Keep code, commands, identifiers, API names, and product names unchanged.

Write in English.

Write in clear Indian English for beginner software developers in India.

Translate every word literally and make every sentence sound completely natural.

Preserve the exact meaning while using natural sentence structure in the target language.

Use the supplied glossary exactly.
Do not replace approved terms with synonyms.

Translate all unknown terms.

Keep uncertain terms unchanged and add them to a review list.

Give the answer in English and Marathi.

Present the complete English explanation first.
Present the equivalent Marathi explanation second.
Keep both sections equal in detail.

# Purpose: Process multilingual content with controlled translation and localisation
Task: {task}
Source language: {source_language}
Target language: {target_language}
Target script: {target_script}
Target locale: {target_locale}
Target audience: {target_audience}
Audience knowledge level: {knowledge_level}
Translation style: {translation_style}
Tone: {tone}
Formality level: {formality_level}
Technical domain: {technical_domain}
Output format: {output_format}
Word limit: {word_limit}
Preserve these terms: {preserve_terms}
Approved terminology glossary: {terminology_glossary}
Preserve the original meaning, intent, certainty level, facts, conditions, warnings, and limitations.
Preserve names, dates, numbers, units, product names, technical identifiers, file paths, commands, URLs, and code.
Use the approved glossary consistently.
Adapt dates, times, currency, measurements, examples, and cultural references only when localisation is required.
Use natural grammar and expressions for the target locale.
Do not add unsupported facts.
Do not remove important details.
Do not translate untranslatable terms inaccurately.
Keep untranslatable terms unchanged and explain them after first use.
Mark uncertain terms for human review.
Preserve headings, lists, tables, paragraph breaks, and document order.
Include the original content when {include_source} is yes.
Include transliteration when {include_transliteration} is yes.
Translate code comments when {translate_comments} is yes.
Return only the requested output unless {include_notes} is yes.
Content: {content}

# Purpose: Translate Java documentation into Marathi
Translate the following technical documentation from English to Marathi.
Use Devanagari script.
Write for beginner Java developers.
Use a clear educational tone.
Use natural Marathi sentence structure.
Preserve the original technical meaning.
Keep Java, JVM, JDK, Spring Boot, API, class names, method names, keywords, code, commands, file paths, and URLs unchanged.
Preserve headings, lists, tables, and paragraph structure.
Explain difficult technical terms in Marathi when first used.
Do not add unsupported technical information.
Mark uncertain terms for review.
Return the result in Markdown.
Content: A Java interface defines a contract that implementing classes must follow.

Java interface हा एक contract परिभाषित करतो, ज्याचे पालन त्याची अंमलबजावणी करणाऱ्या classes ने करणे आवश्यक असते.